Introduce chrome.braveTheme api

browser/extensions/BUILD.gn

@@ -12,6 +12,8 @@ source_set("extensions") {
     "api/brave_sync_api.h",
     "api/brave_sync_event_router.cc",
     "api/brave_sync_event_router.h",
+    "api/brave_theme_api.cc",
+    "api/brave_theme_api.h",
     "api/settings_private/brave_prefs_util.cc",
     "api/settings_private/brave_prefs_util.h",
     "brave_component_extension.cc",
@@ -30,6 +32,8 @@ source_set("extensions") {
     "brave_extension_provider.h",
     "brave_extension_service.cc",
     "brave_extension_service.h",
+    "brave_theme_event_router.cc",
+    "brave_theme_event_router.h",
     "brave_tor_client_updater.cc",
     "brave_tor_client_updater.h",
   ]

browser/extensions/api/brave_theme_api.cc

@@ -0,0 +1,63 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "brave/browser/extensions/api/brave_theme_api.h"
+
+#include <string>
+
+#include "base/values.h"
+#include "brave/browser/themes/brave_theme_service.h"
+#include "brave/common/extensions/api/brave_theme.h"
+#include "brave/common/pref_names.h"
+#include "chrome/browser/profiles/profile.h"
+#include "components/prefs/pref_service.h"
+
+using BTS = BraveThemeService;
+
+namespace {
+void SetBraveThemeTypePref(Profile* profile,
+                           BraveThemeType type) {
+  profile->GetPrefs()->SetInteger(kBraveThemeType, type);
+}
+
+BraveThemeType GetBraveThemeTypeFromString(
+    base::StringPiece theme) {
+  if (theme == "Default")
+    return BraveThemeType::BRAVE_THEME_TYPE_DEFAULT;
+
+  if (theme == "Light")
+    return BraveThemeType::BRAVE_THEME_TYPE_LIGHT;
+
+  if (theme == "Dark")
+    return BraveThemeType::BRAVE_THEME_TYPE_DARK;
+
+  NOTREACHED();
+  return BraveThemeType::BRAVE_THEME_TYPE_DEFAULT;
+}
+
+}  // namespace
+
+namespace extensions {
+namespace api {
+
+ExtensionFunction::ResponseAction BraveThemeSetBraveThemeTypeFunction::Run() {
+  std::unique_ptr<brave_theme::SetBraveThemeType::Params> params(
+      brave_theme::SetBraveThemeType::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  SetBraveThemeTypePref(profile, GetBraveThemeTypeFromString(params->type));
+
+  return RespondNow(NoArguments());
+}
+
+ExtensionFunction::ResponseAction BraveThemeGetBraveThemeTypeFunction::Run() {
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  const std::string theme_type = BTS::GetStringFromBraveThemeType(
+      BTS::GetActiveBraveThemeType(profile));
+  return RespondNow(OneArgument(std::make_unique<base::Value>(theme_type)));
+}
+
+}  // namespace api
+}  // namespace extensions

browser/extensions/api/brave_theme_api.h

@@ -0,0 +1,36 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef BRAVE_BROWSER_EXTENSIONS_API_BRAVE_THEME_API_H_
+#define BRAVE_BROWSER_EXTENSIONS_API_BRAVE_THEME_API_H_
+
+#include "extensions/browser/extension_function.h"
+
+namespace extensions {
+namespace api {
+
+class BraveThemeSetBraveThemeTypeFunction : public UIThreadExtensionFunction {
+ public:
+  DECLARE_EXTENSION_FUNCTION("braveTheme.setBraveThemeType", UNKNOWN)
+
+ protected:
+  ~BraveThemeSetBraveThemeTypeFunction() override {}
+
+  ResponseAction Run() override;
+};
+
+class BraveThemeGetBraveThemeTypeFunction : public UIThreadExtensionFunction {
+  public:
+    DECLARE_EXTENSION_FUNCTION("braveTheme.getBraveThemeType", UNKNOWN)
+
+  protected:
+    ~BraveThemeGetBraveThemeTypeFunction() override {}
+
+    ResponseAction Run() override;
+};
+
+}  // namespace api
+}  // namespace extensions
+
+#endif  // BRAVE_BROWSER_EXTENSIONS_API_BRAVE_THEME_API_H_

browser/extensions/api/brave_theme_api_browsertest.cc

@@ -0,0 +1,107 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "base/values.h"
+#include "brave/browser/extensions/api/brave_theme_api.h"
+#include "brave/browser/extensions/brave_theme_event_router.h"
+#include "brave/browser/themes/brave_theme_service.h"
+#include "brave/browser/themes/theme_properties.h"
+#include "brave/common/pref_names.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "chrome/browser/extensions/extension_function_test_utils.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/themes/theme_properties.h"
+#include "chrome/browser/themes/theme_service_factory.h"
+#include "chrome/browser/ui/browser.h"
+#include "components/prefs/pref_service.h"
+#include "extensions/common/extension_builder.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+using extensions::api::BraveThemeGetBraveThemeTypeFunction;
+using extensions::api::BraveThemeSetBraveThemeTypeFunction;
+using extension_function_test_utils::RunFunctionAndReturnSingleResult;
+using BTS = BraveThemeService;
+
+class BraveThemeAPIBrowserTest : public InProcessBrowserTest {
+  public:
+    void SetUpOnMainThread() override {
+      InProcessBrowserTest::SetUpOnMainThread();
+      extension_ = extensions::ExtensionBuilder("Test").Build();
+    }
+
+    scoped_refptr<const extensions::Extension> extension() {
+      return extension_;
+    }
+
+  private:
+    scoped_refptr<const extensions::Extension> extension_;
+};
+
+namespace {
+class MockBraveThemeEventRouter : public extensions::BraveThemeEventRouter {
+ public:
+  MockBraveThemeEventRouter() {}
+  ~MockBraveThemeEventRouter() override {}
+
+  MOCK_METHOD1(OnBraveThemeTypeChanged, void(Profile*));
+};
+
+void SetBraveThemeType(Profile* profile, BraveThemeType type) {
+  profile->GetPrefs()->SetInteger(kBraveThemeType, type);
+}
+}  // namespace
+
+IN_PROC_BROWSER_TEST_F(BraveThemeAPIBrowserTest,
+                       BraveThemeGetBraveThemeTypeTest) {
+  Profile* profile = browser()->profile();
+
+  // Check default type is set initially.
+  EXPECT_EQ(BraveThemeType::BRAVE_THEME_TYPE_DEFAULT,
+            BTS::GetUserPreferredBraveThemeType(profile));
+
+  // Change to Light type and check it from api.
+  SetBraveThemeType(profile, BraveThemeType::BRAVE_THEME_TYPE_LIGHT);
+  EXPECT_EQ(BraveThemeType::BRAVE_THEME_TYPE_LIGHT,
+            BTS::GetUserPreferredBraveThemeType(profile));
+  scoped_refptr<BraveThemeGetBraveThemeTypeFunction> get_function(
+      new BraveThemeGetBraveThemeTypeFunction());
+  get_function->set_extension(extension().get());
+  std::unique_ptr<base::Value> value;
+  value.reset(RunFunctionAndReturnSingleResult(get_function.get(),
+                                               std::string("[]"),
+                                               browser()));
+  EXPECT_EQ(value->GetString(), "Light");
+}
+
+IN_PROC_BROWSER_TEST_F(BraveThemeAPIBrowserTest,
+                       BraveThemeSetBraveThemeTypeTest) {
+  Profile* profile = browser()->profile();
+
+  // Check default type is set initially.
+  EXPECT_EQ(BraveThemeType::BRAVE_THEME_TYPE_DEFAULT,
+            BTS::GetUserPreferredBraveThemeType(profile));
+
+  // Change theme type to Light via api and check it.
+  scoped_refptr<BraveThemeSetBraveThemeTypeFunction> set_function(
+      new BraveThemeSetBraveThemeTypeFunction());
+  set_function->set_extension(extension().get());
+  RunFunctionAndReturnSingleResult(set_function.get(),
+                                   std::string("[\"Light\"]"),
+                                   browser());
+
+  EXPECT_EQ(BraveThemeType::BRAVE_THEME_TYPE_LIGHT,
+            BTS::GetUserPreferredBraveThemeType(profile));
+}
+
+IN_PROC_BROWSER_TEST_F(BraveThemeAPIBrowserTest,
+                       BraveThemeEventRouterTest) {
+  Profile* profile = browser()->profile();
+  MockBraveThemeEventRouter* mock_router_ = new MockBraveThemeEventRouter;
+  EXPECT_CALL(*mock_router_, OnBraveThemeTypeChanged(profile)).Times(1);
+
+  BraveThemeService* service = static_cast<BraveThemeService*>(
+      ThemeServiceFactory::GetForProfile(browser()->profile()));
+  service->SetBraveThemeEventRouterForTesting(mock_router_);
+  SetBraveThemeType(profile, BraveThemeType::BRAVE_THEME_TYPE_LIGHT);
+}

browser/extensions/brave_theme_event_router.cc

@@ -0,0 +1,47 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "brave/browser/extensions/brave_theme_event_router.h"
+
+#include "brave/browser/themes/brave_theme_service.h"
+#include "brave/common/extensions/api/brave_theme.h"
+#include "chrome/browser/profiles/profile.h"
+#include "extensions/browser/event_router.h"
+#include "extensions/browser/extension_event_histogram_value.h"
+
+using BTS = BraveThemeService;
+
+namespace extensions {
+
+class BraveThemeEventRouterImpl : public BraveThemeEventRouter {
+ public:
+  BraveThemeEventRouterImpl() {}
+  ~BraveThemeEventRouterImpl() override {}
+
+  void OnBraveThemeTypeChanged(Profile* profile) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(BraveThemeEventRouterImpl);
+};
+
+void BraveThemeEventRouterImpl::OnBraveThemeTypeChanged(Profile* profile) {
+  EventRouter* event_router = EventRouter::Get(profile);
+  const std::string theme_type = BTS::GetStringFromBraveThemeType(
+      BTS::GetActiveBraveThemeType(profile));
+
+  auto event = std::make_unique<extensions::Event>(
+      extensions::events::BRAVE_ON_BRAVE_THEME_TYPE_CHANGED,
+      api::brave_theme::OnBraveThemeTypeChanged::kEventName,
+      api::brave_theme::OnBraveThemeTypeChanged::Create(theme_type),
+      profile);
+
+  event_router->BroadcastEvent(std::move(event));
+}
+
+// static
+std::unique_ptr<BraveThemeEventRouter> BraveThemeEventRouter::Create() {
+  return std::make_unique<BraveThemeEventRouterImpl>();
+}
+
+}  // namespace extensions

browser/extensions/brave_theme_event_router.h

@@ -0,0 +1,25 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef BRAVE_BROWSER_EXTENSIONS_BRAVE_THEME_EVENT_ROUTER_H_
+#define BRAVE_BROWSER_EXTENSIONS_BRAVE_THEME_EVENT_ROUTER_H_
+
+#include <memory>
+
+class Profile;
+
+namespace extensions {
+
+class BraveThemeEventRouter {
+ public:
+  static std::unique_ptr<BraveThemeEventRouter> Create();
+
+  virtual ~BraveThemeEventRouter() {}
+
+  virtual void OnBraveThemeTypeChanged(Profile* profile) = 0;
+};
+
+}  // namespace extensions
+
+#endif  // BRAVE_BROWSER_EXTENSIONS_BRAVE_THEME_EVENT_ROUTER_H_

browser/resources/settings/brave_appearance_page/brave_appearance_browser_proxy.js

@@ -21,12 +21,12 @@ cr.define('settings', function() {
   class BraveAppearanceBrowserProxyImpl {
     /** @override */
     getBraveThemeType() {
-      return cr.sendWithPromise('getBraveThemeType');
+      return new Promise(resolve => chrome.braveTheme.getBraveThemeType(resolve))
     }
 
     /** @override */
     setBraveThemeType(theme) {
-      chrome.send('setBraveThemeType', [theme]);
+      chrome.braveTheme.setBraveThemeType(theme);
     }
   }
 

browser/resources/settings/brave_appearance_page/brave_appearance_page.js

@@ -13,7 +13,6 @@ Polymer({
       readOnly: true,
       type: Array,
       value: [
-        'Default',
         'Light',
         'Dark',
       ],
@@ -58,4 +57,4 @@ Polymer({
 Polymer({
   is: 'settings-brave-appearance-toolbar',
 });
-})();
+})();