Make extensions developer mode adhere to policy

chrome/browser/policy/configuration_policy_handler_list_factory.cc

 // Copyright 2013 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/policy/configuration_policy_handler_list_factory.h"
 
 #include <limits.h>
 #include <stddef.h>
 
 #include <utility>
@@ skipping 138 matching lines @@
     base::Value::TYPE_BOOLEAN },
   { key::kShowHomeButton,
     prefs::kShowHomeButton,
     base::Value::TYPE_BOOLEAN },
   { key::kSavingBrowserHistoryDisabled,
     prefs::kSavingBrowserHistoryDisabled,
     base::Value::TYPE_BOOLEAN },
   { key::kAllowDeletingBrowserHistory,
     prefs::kAllowDeletingBrowserHistory,
     base::Value::TYPE_BOOLEAN },
   { key::kDeveloperToolsDisabled,

[Bernhard Bauer, 2016/11/28 17:11:03]

Could you just duplicate this entry with prefs::kExtensionsUIDeveloperMode?

[pmarko, 2016/11/29 12:40:21]

Actually, I don't think I could - the issue is that this has to be negated:
If kDeveloperToolDisabled is true, kExtensionsUIDeveloperMode shall be forced to
false. That's why we need a special handler.

     prefs::kDevToolsDisabled,
     base::Value::TYPE_BOOLEAN },
   { key::kBlockThirdPartyCookies,
     prefs::kBlockThirdPartyCookies,
     base::Value::TYPE_BOOLEAN },
   { key::kDefaultCookiesSetting,
     prefs::kManagedDefaultCookiesSetting,
     base::Value::TYPE_INTEGER },
   { key::kDefaultImagesSetting,
     prefs::kManagedDefaultImagesSetting,
@@ skipping 531 matching lines @@
        index < extensions::schema_constants::kAllowedTypesMapSize;
        ++index) {
     const extensions::schema_constants::AllowedTypesMapEntry& entry =
         extensions::schema_constants::kAllowedTypesMap[index];
     result->push_back(
         base::MakeUnique<StringMappingListPolicyHandler::MappingEntry>(
             entry.name, std::unique_ptr<base::Value>(
                             new base::FundamentalValue(entry.manifest_type))));
   }
 }
+
+// Piggy-back kDeveloperToolsDisabled set to true to also force-disable
+// kExtensionsUIDeveloperMode.
+class DevToolsExtensionsUIPolicyHandler : public TypeCheckingPolicyHandler {
+ public:
+  DevToolsExtensionsUIPolicyHandler()
+      : TypeCheckingPolicyHandler(key::kDeveloperToolsDisabled,
+                                  base::Value::TYPE_BOOLEAN) {}
+  ~DevToolsExtensionsUIPolicyHandler() override {}
+
+  // ConfigurationPolicyHandler implementation:
+  void ApplyPolicySettings(const PolicyMap& policies,
+                           PrefValueMap* prefs) override {
+    const base::Value* value = policies.GetValue(policy_name());
+    bool developerToolsDisabled;
+    if (value &&
+        value->GetAsBoolean(&developerToolsDisabled) &&
+        developerToolsDisabled) {
+      prefs->SetValue(
+          prefs::kExtensionsUIDeveloperMode,
+          base::MakeUnique<base::FundamentalValue>(false));
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DevToolsExtensionsUIPolicyHandler);
+};
 #endif
 
 void GetDeprecatedFeaturesMap(
     std::vector<std::unique_ptr<StringMappingListPolicyHandler::MappingEntry>>*
         result) {
   // Maps feature tags as specified in policy to the corresponding switch to
   // re-enable them.
 }
 
 }  // namespace
@@ skipping 65 matching lines @@
   handlers->AddHandler(
       base::MakeUnique<extensions::ExtensionURLPatternListPolicyHandler>(
           key::kExtensionInstallSources,
           extensions::pref_names::kAllowedInstallSites));
   handlers->AddHandler(base::MakeUnique<StringMappingListPolicyHandler>(
       key::kExtensionAllowedTypes, extensions::pref_names::kAllowedTypes,
       base::Bind(GetExtensionAllowedTypesMap)));
   handlers->AddHandler(
       base::MakeUnique<extensions::ExtensionSettingsPolicyHandler>(
           chrome_schema));
+  handlers->AddHandler(
+      base::MakeUnique<DevToolsExtensionsUIPolicyHandler>());
 #endif
 
 #if !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
   handlers->AddHandler(base::MakeUnique<DiskCacheDirPolicyHandler>());
 
   handlers->AddHandler(
       base::MakeUnique<extensions::NativeMessagingHostListPolicyHandler>(
           key::kNativeMessagingWhitelist,
           extensions::pref_names::kNativeMessagingWhitelist, false));
   handlers->AddHandler(
@@ skipping 122 matching lines @@
 #endif  // defined(OS_CHROMEOS)
 
 #if BUILDFLAG(ENABLE_PLUGINS)
   handlers->AddHandler(base::MakeUnique<PluginPolicyHandler>());
 #endif  // BUILDFLAG(ENABLE_PLUGINS)
 
   return handlers;
 }
 
 }  // namespace policy