Create --disable-extensions-except switch

chrome/browser/extensions/extension_service.h

 // Copyright (c) 2012 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 439 matching lines @@
     browser_terminating_ = value;
   }
 
   // Set a callback to be called when all external providers are ready and their
   // extensions have been installed.
   void set_external_updates_finished_callback_for_test(
       const base::Closure& callback) {
     external_updates_finished_callback_ = callback;
   }
 
+  void AddExtensionToExemptedFromDisableFlag(const std::string& extensionId) {

[Devlin, 2016/08/10 19:22:31]

A few notes here.
- These functions are pretty simple, and are only used once.  We can probably
get rid of them and do the work directly.
- If we keep them, they shouldn't be in the public: section, since they're only
used internally.
- If we keep them, they should go up with the other "regular" functions, rather
than in the For Testing section.

[catmullings, 2016/08/29 20:42:27]

I'll go with the first option.

Done.

+    disable_flag_exempted_extensions_.insert(extensionId);
+  }
+
+  bool IsExtensionExemptedFromDisableFlag(const std::string& extensionId) {
+    return disable_flag_exempted_extensions_.find(extensionId) !=
+           disable_flag_exempted_extensions_.end();
+  }
+
  private:
+  void LoadExtensionsFromCommandLineFlag(const char* switch_name);
+
   // Reloads the specified extension, sending the onLaunched() event to it if it
   // currently has any window showing. |be_noisy| determines whether noisy
   // failures are allowed for unpacked extension installs.
   void ReloadExtensionImpl(const std::string& extension_id, bool be_noisy);
 
   // content::NotificationObserver implementation:
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override;
 
@@ skipping 116 matching lines @@
   // the actual profile objects to be destroyed.
   void OnProfileDestructionStarted();
 
   // Called on file task runner thread to uninstall extension.
   static void UninstallExtensionOnFileThread(
       const std::string& id,
       Profile* profile,
       const base::FilePath& install_dir,
       const base::FilePath& extension_path);
 
+  const base::CommandLine* command_line_ = nullptr;
+
   // The normal profile associated with this ExtensionService.
   Profile* profile_ = nullptr;
 
   // The ExtensionSystem for the profile above.
   extensions::ExtensionSystem* system_ = nullptr;
 
   // Preferences for the owning profile.
   extensions::ExtensionPrefs* extension_prefs_ = nullptr;
 
   // Blacklist for the owning profile.
   extensions::Blacklist* blacklist_ = nullptr;
 
   // Sets of enabled/disabled/terminated/blacklisted extensions. Not owned.
   extensions::ExtensionRegistry* registry_ = nullptr;
 
   // Set of greylisted extensions. These extensions are disabled if they are
   // already installed in Chromium at the time when they are added to
   // the greylist. Unlike blacklisted extensions, greylisted ones are visible
   // to the user and if user re-enables such an extension, they remain enabled.
   //
   // These extensions should appear in registry_.
   extensions::ExtensionSet greylist_;
 
+  // Set of whitelisted enabled extensions loaded from the
+  // --disable-extensions-except command line flag.
+  std::set<std::string> disable_flag_exempted_extensions_;
+
   // The list of extension installs delayed for various reasons.  The reason
   // for delayed install is stored in ExtensionPrefs. These are not part of
   // ExtensionRegistry because they are not yet installed.
   extensions::ExtensionSet delayed_installs_;
 
   // Hold the set of pending extensions.
   extensions::PendingExtensionManager pending_extension_manager_;
 
   // The full path to the directory where extensions are installed.
   base::FilePath install_directory_;
@@ skipping 116 matching lines @@
                            GreylistUnknownDontChange);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            ManagementPolicyProhibitsEnableOnInstalled);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            BlockAndUnblockBlacklistedExtension);
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_