Make extensions developer mode adhere to policy

chrome/browser/extensions/api/developer_private/developer_private_api_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/api/developer_private/developer_private_api.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/error_console/error_console.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/scripting_permissions_modifier.h"
 #include "chrome/browser/extensions/test_extension_dir.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/extensions/api/developer_private.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/test_browser_window.h"
 #include "components/crx_file/id_util.h"
+#include "components/policy/core/browser/browser_policy_connector.h"
+#include "components/policy/core/common/mock_configuration_policy_provider.h"
+#include "components/policy/core/common/policy_map.h"
+#include "components/policy/core/common/policy_service_impl.h"
+#include "components/policy/core/common/policy_types.h"
+#include "components/policy/policy_constants.h"
+#include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "content/public/test/web_contents_tester.h"
 #include "extensions/browser/event_router_factory.h"
 #include "extensions/browser/extension_error_test_util.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/test_extension_registry_observer.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/test_util.h"
 #include "extensions/common/value_builder.h"
 
+using testing::Return;
+using testing::_;
+
 namespace extensions {
 
 namespace {
 
 std::unique_ptr<KeyedService> BuildAPI(content::BrowserContext* context) {
   return base::MakeUnique<DeveloperPrivateAPI>(context);
 }
 
 std::unique_ptr<KeyedService> BuildEventRouter(
     content::BrowserContext* profile) {
@@ skipping 35 matching lines @@
   // Tests modifying the extension's configuration.
   void TestExtensionPrefSetting(const base::Callback<bool()>& has_pref,
                                 const std::string& key,
                                 const std::string& extension_id);
 
   testing::AssertionResult TestPackExtensionFunction(
       const base::ListValue& args,
       api::developer_private::PackStatus expected_status,
       int expected_flags);
 
+  // Execute the updateProfileConfiguration API call with a specified
+  // dev_mode. This is done from the webui when the user checks the
+  // "Developer Mode" checkbox.
+  void UpdateProfileConfigurationDevMode(bool dev_mode);
+
+  // Execute the getProfileConfiguration API and parse its result into a
+  // ProfileInfo structure for further verification in the calling test.
+  std::unique_ptr<api::developer_private::ProfileInfo>
+      GetProfileConfiguration();
+
   Browser* browser() { return browser_.get(); }
 
  private:
   // ExtensionServiceTestBase:
   void SetUp() override;
   void TearDown() override;
 
   // The browser (and accompanying window).
   std::unique_ptr<TestBrowserWindow> browser_window_;
   std::unique_ptr<Browser> browser_;
 
   std::vector<std::unique_ptr<TestExtensionDir>> test_extension_dirs_;
+  policy::MockConfigurationPolicyProvider mock_policy_provider_;
 
   DISALLOW_COPY_AND_ASSIGN(DeveloperPrivateApiUnitTest);
 };
 
 bool DeveloperPrivateApiUnitTest::RunFunction(
     const scoped_refptr<UIThreadExtensionFunction>& function,
     const base::ListValue& args) {
   return extension_function_test_utils::RunFunction(
       function.get(), args.CreateDeepCopy(), browser(),
       extension_function_test_utils::NONE);
@@ skipping 115 matching lines @@
   }
 
   if (response->override_flags != expected_flags) {
     return testing::AssertionFailure() << "Expected flags: " <<
         expected_flags << ", found flags: " << response->override_flags;
   }
 
   return testing::AssertionSuccess();
 }
 
+void DeveloperPrivateApiUnitTest::UpdateProfileConfigurationDevMode(
+    bool dev_mode) {
+  scoped_refptr<UIThreadExtensionFunction> function(
+      new api::DeveloperPrivateUpdateProfileConfigurationFunction());
+  std::unique_ptr<base::ListValue> args =
+      ListBuilder()
+          .Append(DictionaryBuilder()
+                      .SetBoolean("inDeveloperMode", dev_mode)
+                      .Build())
+          .Build();
+  EXPECT_TRUE(RunFunction(function, *args)) << function->GetError();
+}
+
+std::unique_ptr<api::developer_private::ProfileInfo>
+    DeveloperPrivateApiUnitTest::GetProfileConfiguration() {
+  scoped_refptr<UIThreadExtensionFunction> function(
+      new api::DeveloperPrivateGetProfileConfigurationFunction());
+  base::ListValue args;
+  EXPECT_TRUE(RunFunction(function, args)) << function->GetError();
+
+  EXPECT_TRUE(function->GetResultList());

[Andrew T Wilson (Slow), 2016/12/04 14:54:54]

ASSERT_TRUE() because your test will crash on the next line if this ever returns
nullptr, so you might as well terminate the test now.

[pmarko, 2016/12/07 16:12:11]

Good point - had have to change the method type to void for that but I think
that's a good trade-off. 

+  EXPECT_EQ(1u, function->GetResultList()->GetSize());

[Andrew T Wilson (Slow), 2016/12/04 14:54:54]

I'd probably also ASSERT_EQ or ASSERT_GE here because the code below will crash
if the result list is zero-sized.

[Andrew T Wilson (Slow), 2016/12/04 14:54:54]

I'd probably also ASSERT_EQ or ASSERT_GE here because the code below will crash
if the result list is zero-sized.

[pmarko, 2016/12/07 16:12:11]

Done - taking ASSERT_EQ because the API is supposed to return exactly one
response.

+  const base::Value* response_value = nullptr;
+  function->GetResultList()->Get(0u, &response_value);
+  std::unique_ptr<api::developer_private::ProfileInfo> response =
+      api::developer_private::ProfileInfo::FromValue(*response_value);
+  return response;
+}
+
 void DeveloperPrivateApiUnitTest::SetUp() {
   ExtensionServiceTestBase::SetUp();
-  InitializeEmptyExtensionService();
+
+  // By not specifying a pref_file filepath, we get a
+  // sync_preferences::TestingPrefServiceSyncable
+  // - see BuildTestingProfile in extension_service_test_base.cc.
+  ExtensionServiceInitParams init_params = CreateDefaultInitParams();
+  init_params.pref_file.clear();
+  InitializeExtensionService(init_params);
 
   browser_window_.reset(new TestBrowserWindow());
   Browser::CreateParams params(profile());
   params.type = Browser::TYPE_TABBED;
   params.window = browser_window_.get();
   browser_.reset(new Browser(params));
 
   // Allow the API to be created.
   EventRouterFactory::GetInstance()->SetTestingFactory(profile(),
                                                        &BuildEventRouter);
@@ skipping 311 matching lines @@
       ListBuilder()
           .Append(
               DictionaryBuilder().Set("extensionId", extension->id()).Build())
           .Build();
   function = new api::DeveloperPrivateDeleteExtensionErrorsFunction();
   EXPECT_TRUE(RunFunction(function, *args)) << function->GetError();
   // No more errors!
   EXPECT_TRUE(error_console->GetErrorsForExtension(extension->id()).empty());
 }
 
+// Test developerPrivate.updateProfileConfiguration
+// trying to turn on devMode when DeveloperToolsDisabled policy is active
+TEST_F(DeveloperPrivateApiUnitTest, DeveloperPrivateDevModeDisabledPolicy) {
+  testing_pref_service()->SetManagedPref(
+       prefs::kExtensionsUIDeveloperMode,
+       new base::FundamentalValue(false));
+
+  UpdateProfileConfigurationDevMode(true);
+
+  EXPECT_FALSE(
+      profile()->GetPrefs()->GetBoolean(prefs::kExtensionsUIDeveloperMode));
+
+  std::unique_ptr<api::developer_private::ProfileInfo> profile_info =
+      GetProfileConfiguration();
+  EXPECT_FALSE(profile_info->in_developer_mode);
+  EXPECT_TRUE(profile_info->is_developer_mode_controlled_by_policy);
+}
+
+// Test developerPrivate.updateProfileConfiguration
+// trying to turn on devMode
+TEST_F(DeveloperPrivateApiUnitTest, DeveloperPrivateDevMode) {
+  EXPECT_FALSE(
+      profile()->GetPrefs()->GetBoolean(prefs::kExtensionsUIDeveloperMode));
+
+  UpdateProfileConfigurationDevMode(true);
+
+  EXPECT_TRUE(
+      profile()->GetPrefs()->GetBoolean(prefs::kExtensionsUIDeveloperMode));
+
+  std::unique_ptr<api::developer_private::ProfileInfo> profile_info =
+      GetProfileConfiguration();
+  EXPECT_TRUE(profile_info->in_developer_mode);
+  EXPECT_FALSE(profile_info->is_developer_mode_controlled_by_policy);
+}
+
 }  // namespace extensions