Don't show a prompt when loading an extension with NPAPI plugins via

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2011 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 <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 211 matching lines @@
 
 class ExtensionServiceBackend
     : public base::RefCountedThreadSafe<ExtensionServiceBackend> {
  public:
   // |install_directory| is a path where to look for extensions to load.
   ExtensionServiceBackend(
       base::WeakPtr<ExtensionService> frontend,
       const FilePath& install_directory);
 
   // Loads a single extension from |path| where |path| is the top directory of
-  // a specific extension where its manifest file lives.
+  // a specific extension where its manifest file lives. If |prompt_for_plugins|
+  // is true and the extension contains plugins, we prompt the user before
+  // loading.
   // Errors are reported through ExtensionErrorReporter. On success,
   // AddExtension() is called.
   // TODO(erikkay): It might be useful to be able to load a packed extension
   // (presumably into memory) without installing it.
-  void LoadSingleExtension(const FilePath &path);
+  void LoadSingleExtension(const FilePath &path, bool prompt_for_plugins);
 
  private:
   friend class base::RefCountedThreadSafe<ExtensionServiceBackend>;
 
   virtual ~ExtensionServiceBackend();
 
   // LoadSingleExtension needs to check the file access preference, which needs
   // to happen back on the UI thread, so it posts CheckExtensionFileAccess on
   // the UI thread. In turn, once that gets the pref, it goes back to the
   // file thread with LoadSingleExtensionWithFileAccess.
-  void CheckExtensionFileAccess(const FilePath& extension_path);
+  void CheckExtensionFileAccess(const FilePath& extension_path,
+                                bool prompt_for_plugins);
   void LoadSingleExtensionWithFileAccess(
-      const FilePath &path, bool allow_file_access);
+      const FilePath &path, bool allow_file_access, bool prompt_for_plugins);
 
   // Notify the frontend that there was an error loading an extension.
   void ReportExtensionLoadError(const FilePath& extension_path,
                                 const std::string& error);
 
   // Notify the frontend that an extension was installed.
-  void OnLoadSingleExtension(const scoped_refptr<const Extension>& extension);
+  void OnLoadSingleExtension(const scoped_refptr<const Extension>& extension,
+                             bool prompt_for_plugins);
 
   base::WeakPtr<ExtensionService> frontend_;
 
   // The top-level extensions directory being installed to.
   FilePath install_directory_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionServiceBackend);
 };
 
 ExtensionServiceBackend::ExtensionServiceBackend(
     base::WeakPtr<ExtensionService> frontend,
     const FilePath& install_directory)
         : frontend_(frontend),
           install_directory_(install_directory) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 ExtensionServiceBackend::~ExtensionServiceBackend() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
         BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
-void ExtensionServiceBackend::LoadSingleExtension(const FilePath& path_in) {
+void ExtensionServiceBackend::LoadSingleExtension(const FilePath& path_in,
+                                                  bool prompt_for_plugins) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   FilePath extension_path = path_in;
   file_util::AbsolutePath(&extension_path);
 
-  if (!BrowserThread::PostTask(
-            BrowserThread::UI, FROM_HERE,
-            NewRunnableMethod(
-                this,
-                &ExtensionServiceBackend::CheckExtensionFileAccess,
-                extension_path)))
-    NOTREACHED();
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+      NewRunnableMethod(this,
+                        &ExtensionServiceBackend::CheckExtensionFileAccess,
+                        extension_path, prompt_for_plugins));
 }
 
 void ExtensionServiceBackend::CheckExtensionFileAccess(
-    const FilePath& extension_path) {
+    const FilePath& extension_path, bool prompt_for_plugins) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   std::string id = Extension::GenerateIdForPath(extension_path);
   // Unpacked extensions default to allowing file access, but if that has been
   // overridden, don't reset the value.
   bool allow_file_access =
       Extension::ShouldAlwaysAllowFileAccess(Extension::LOAD) &&
       !frontend_->extension_prefs()->HasAllowFileAccessSetting(id);
 
-  if (!BrowserThread::PostTask(
-          BrowserThread::FILE, FROM_HERE,
-          NewRunnableMethod(
-              this,
-              &ExtensionServiceBackend::LoadSingleExtensionWithFileAccess,
-              extension_path,
-              allow_file_access)))
-    NOTREACHED();
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+      NewRunnableMethod(
+          this,
+          &ExtensionServiceBackend::LoadSingleExtensionWithFileAccess,
+          extension_path, allow_file_access, prompt_for_plugins));
 }
 
-
 void ExtensionServiceBackend::LoadSingleExtensionWithFileAccess(
-    const FilePath& extension_path, bool allow_file_access) {
+    const FilePath& extension_path,
+    bool allow_file_access,
+    bool prompt_for_plugins) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   int flags = allow_file_access ?
       Extension::ALLOW_FILE_ACCESS : Extension::NO_FLAGS;
   if (Extension::ShouldDoStrictErrorChecking(Extension::LOAD))
     flags |= Extension::STRICT_ERROR_CHECKS;
   std::string error;
   scoped_refptr<const Extension> extension(extension_file_util::LoadExtension(
       extension_path,
       Extension::LOAD,
       flags,
       &error));
 
   if (!extension) {
-    if (!BrowserThread::PostTask(
-            BrowserThread::UI, FROM_HERE,
-            NewRunnableMethod(
-                this,
-                &ExtensionServiceBackend::ReportExtensionLoadError,
-                extension_path, error)))
-      NOTREACHED() << error;
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+        NewRunnableMethod(
+            this,
+            &ExtensionServiceBackend::ReportExtensionLoadError,
+            extension_path, error));
     return;
   }
 
   // Report this as an installed extension so that it gets remembered in the
   // prefs.
-  if (!BrowserThread::PostTask(
-          BrowserThread::UI, FROM_HERE,
-          NewRunnableMethod(
-              this,
-              &ExtensionServiceBackend::OnLoadSingleExtension,
-              extension)))
-    NOTREACHED();
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+      NewRunnableMethod(
+          this,
+          &ExtensionServiceBackend::OnLoadSingleExtension,
+          extension, prompt_for_plugins));
 }
 
 void ExtensionServiceBackend::ReportExtensionLoadError(
     const FilePath& extension_path, const std::string &error) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (frontend_.get())
     frontend_->ReportExtensionLoadError(
         extension_path, error, chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
         true /* alert_on_error */);
 }
 
 void ExtensionServiceBackend::OnLoadSingleExtension(
-    const scoped_refptr<const Extension>& extension) {
+    const scoped_refptr<const Extension>& extension, bool prompt_for_plugins) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (frontend_.get())
-    frontend_->OnLoadSingleExtension(extension);
+    frontend_->OnLoadSingleExtension(extension, prompt_for_plugins);
 }
 
 void ExtensionService::CheckExternalUninstall(const std::string& id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Check if the providers know about this extension.
   ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
     DCHECK(i->get()->IsReady());
@@ skipping 616 matching lines @@
     const Extension* extension) {
   CHECK(extension);
   RecordPermissionMessagesHistogram(
       extension, "Extensions.Permissions_ReEnable");
   GrantPermissions(extension);
   extension_prefs_->SetDidExtensionEscalatePermissions(extension, false);
   EnableExtension(extension->id());
 }
 
 void ExtensionService::LoadExtension(const FilePath& extension_path) {
-  if (!BrowserThread::PostTask(
-          BrowserThread::FILE, FROM_HERE,
-          NewRunnableMethod(
-              backend_.get(),
-              &ExtensionServiceBackend::LoadSingleExtension,
-              extension_path)))
-    NOTREACHED();
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+      NewRunnableMethod(backend_.get(),
+                        &ExtensionServiceBackend::LoadSingleExtension,
+                        extension_path, true));
+}
+
+void ExtensionService::LoadExtensionFromCommandLine(
+    const FilePath& extension_path) {
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+      NewRunnableMethod(backend_.get(),
+                        &ExtensionServiceBackend::LoadSingleExtension,
+                        extension_path, false));
 }
 
 void ExtensionService::LoadComponentExtensions() {
   for (RegisteredComponentExtensions::iterator it =
            component_extension_manifests_.begin();
        it != component_extension_manifests_.end(); ++it) {
     LoadComponentExtension(*it);
   }
 }
 
@@ skipping 988 matching lines @@
   std::set<std::string> extension_ids;
   for (size_t i = 0; i < extensions_.size(); ++i) {
     if (!extensions_[i]->is_theme() &&
         extensions_[i]->location() != Extension::COMPONENT)
       extension_ids.insert(extensions_[i]->id());
   }
 
   child_process_logging::SetActiveExtensions(extension_ids);
 }
 
-void ExtensionService::OnLoadSingleExtension(const Extension* extension) {
+void ExtensionService::OnLoadSingleExtension(const Extension* extension,
+                                             bool prompt_for_plugins) {
   // If this is a new install of an extension with plugins, prompt the user
   // first.
-  if (show_extensions_prompts_ &&
+  if (show_extensions_prompts_ && prompt_for_plugins &&
       !extension->plugins().empty() &&
       disabled_extension_paths_.find(extension->id()) ==
           disabled_extension_paths_.end()) {
     SimpleExtensionLoadPrompt* prompt = new SimpleExtensionLoadPrompt(
         profile_, weak_ptr_factory_.GetWeakPtr(), extension);
     prompt->ShowPrompt();
     return;  // continues in SimpleExtensionLoadPrompt::InstallUI*
   }
   OnExtensionInstalled(extension, false);  // Not from web store.
 }
@@ skipping 412 matching lines @@
 
 ExtensionService::NaClModuleInfoList::iterator
     ExtensionService::FindNaClModule(const GURL& url) {
   for (NaClModuleInfoList::iterator iter = nacl_module_list_.begin();
        iter != nacl_module_list_.end(); ++iter) {
     if (iter->url == url)
       return iter;
   }
   return nacl_module_list_.end();
 }