Create --disable-extensions-except switch

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 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/extensions/extension_service.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_tokenizer.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 265 matching lines @@
 
 ExtensionService::ExtensionService(Profile* profile,
                                    const base::CommandLine* command_line,
                                    const base::FilePath& install_directory,
                                    extensions::ExtensionPrefs* extension_prefs,
                                    extensions::Blacklist* blacklist,
                                    bool autoupdate_enabled,
                                    bool extensions_enabled,
                                    extensions::OneShotEvent* ready)
     : extensions::Blacklist::Observer(blacklist),
+      command_line_(command_line),
       profile_(profile),
       system_(extensions::ExtensionSystem::Get(profile)),
       extension_prefs_(extension_prefs),
       blacklist_(blacklist),
       registry_(extensions::ExtensionRegistry::Get(profile)),
       pending_extension_manager_(profile),
       install_directory_(install_directory),
       extensions_enabled_(extensions_enabled),
       ready_(ready),
       shared_module_service_(new extensions::SharedModuleService(profile_)),
@@ skipping 96 matching lines @@
   if (include_disabled) {
     // Include blacklisted and blocked extensions here because there are
     // hundreds of callers of this function, and many might assume that this
     // includes those that have been disabled due to blacklisting or blocking.
     include_mask |= ExtensionRegistry::DISABLED |
                     ExtensionRegistry::BLACKLISTED | ExtensionRegistry::BLOCKED;
   }
   return registry_->GetExtensionById(id, include_mask);
 }
 
+void ExtensionService::LoadExtensionsFromCommandLineFlag(

[Devlin, 2016/08/30 14:15:39]

nit: function definition order in the .cc file should match the function
declaration order in the .h.  This file's already fairly messed up, but we can
try to group this with more private functions.

+    const char* switch_name) {
+  if (command_line_->HasSwitch(switch_name)) {
+    base::CommandLine::StringType path_list =
+        command_line_->GetSwitchValueNative(switch_name);
+    base::StringTokenizerT<base::CommandLine::StringType,
+                           base::CommandLine::StringType::const_iterator>
+        t(path_list, FILE_PATH_LITERAL(","));
+    while (t.GetNext()) {
+      std::string extension_id;
+      extensions::UnpackedInstaller::Create(this)->LoadFromCommandLine(
+          base::FilePath(t.token()), &extension_id, false /*only-allow-apps*/);
+      // Extension id is added to whitelist after its extension is loaded
+      // because code is executed asynchronously ...

[catmullings, 2016/08/29 22:28:01]

Devlin, I didn't quite understand the asynchronous explanation that you gave. 
If the code is executed asynchronously, why does that justify the ordering of
these bits of code?

[Devlin, 2016/08/30 14:15:39]

So, if this code were to be executed synchronously, the flow would be:
1. LoadFromCommandLine()
2. AddExtension()
  - Extension hasn't been added to whitelist; not added to service
3. Add extension id to whitelist

However, since it's async, the flow is:
1. LoadExtensionFromCommandLine() starts
2. Add extension id to whitelist
3. AddExtension()
  - Extension has been added; works as intended

Does that make sense?

+      if (switch_name == switches::kDisableExtensionsExcept) {
+        disable_flag_exempted_extensions_.insert(extension_id);
+      }

[Devlin, 2016/08/30 14:15:39]

nit: We don't have a strong stylistic rule for brackets if-statements with a
single line beyond "match similar code".  But I think the majority of extensions
code avoids brackets on single-line ifs, so this should be just
if (switch_name == ...)
  disable_flag_exempted...

+    }
+  }
+}
+
 void ExtensionService::Init() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TRACE_EVENT0("browser,startup", "ExtensionService::Init");
   SCOPED_UMA_HISTOGRAM_TIMER("Extensions.ExtensionServiceInitTime");
 
   DCHECK(!is_ready());  // Can't redo init.
   DCHECK_EQ(registry_->enabled_extensions().size(), 0u);
 
   // LoadAllExtensions() calls OnLoadedInstalledExtensions().
   component_loader_->LoadAll();
   extensions::InstalledLoader(this).LoadAllExtensions();
-
+  LoadExtensionsFromCommandLineFlag(switches::kDisableExtensionsExcept);
+  if (extensions_enabled_) {

[Devlin, 2016/08/30 14:15:39]

ditto re single line ifs

+    LoadExtensionsFromCommandLineFlag(switches::kLoadExtension);
+  }
   EnabledReloadableExtensions();
   MaybeFinishShutdownDelayed();
   SetReadyAndNotifyListeners();
 
   // TODO(erikkay): this should probably be deferred to a future point
   // rather than running immediately at startup.
   CheckForExternalUpdates();
 
   LoadGreylistFromPrefs();
 }
@@ skipping 974 matching lines @@
     EnableExtension(extension->id());
   }
 
   OnBlacklistUpdated();
 }
 
 void ExtensionService::AddExtension(const Extension* extension) {
   // TODO(jstritar): We may be able to get rid of this branch by overriding the
   // default extension state to DISABLED when the --disable-extensions flag
   // is set (http://crbug.com/29067).
-  if (!extensions_enabled() &&
-      !extension->is_theme() &&
+  if (!extensions_enabled() && !extension->is_theme() &&
       extension->location() != Manifest::COMPONENT &&
-      !Manifest::IsExternalLocation(extension->location())) {
+      !Manifest::IsExternalLocation(extension->location()) &&
+      disable_flag_exempted_extensions_.count(extension->id()) == 0) {
     return;
   }
 
   bool is_extension_upgrade = false;
   bool is_extension_loaded = false;
   const Extension* old = GetInstalledExtension(extension->id());
   if (old) {
     is_extension_loaded = true;
     int version_compare_result =
         extension->version()->CompareTo(*(old->version()));
@@ skipping 1005 matching lines @@
 }
 
 void ExtensionService::OnProfileDestructionStarted() {
   ExtensionIdSet ids_to_unload = registry_->enabled_extensions().GetIDs();
   for (ExtensionIdSet::iterator it = ids_to_unload.begin();
        it != ids_to_unload.end();
        ++it) {
     UnloadExtension(*it, UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN);
   }
 }