Move application restart and relaunch code out of ExtensionService.

chrome/browser/extensions/unpacked_installer.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/unpacked_installer.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/string_util.h"
@@ skipping 77 matching lines @@
 scoped_refptr<UnpackedInstaller> UnpackedInstaller::Create(
     ExtensionService* extension_service) {
   return scoped_refptr<UnpackedInstaller>(
       new UnpackedInstaller(extension_service));
 }
 
 UnpackedInstaller::UnpackedInstaller(ExtensionService* extension_service)
     : service_weak_(extension_service->AsWeakPtr()),
       prompt_for_plugins_(true),
       require_modern_manifest_version_(true),
-      launch_on_load_(false),
       installer_(extension_service->profile()) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 UnpackedInstaller::~UnpackedInstaller() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
         BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 void UnpackedInstaller::Load(const base::FilePath& path_in) {
   DCHECK(extension_path_.empty());
   extension_path_ = path_in;
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&UnpackedInstaller::GetAbsolutePath, this));
 }
 
-void UnpackedInstaller::LoadFromCommandLine(const base::FilePath& path_in,
-                                            bool launch_on_load) {
+bool UnpackedInstaller::LoadFromCommandLine(const base::FilePath& path_in,
+                                            std::string* extension_id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(extension_path_.empty());
 
   if (!service_weak_)
-    return;
+    return false;
   // Load extensions from the command line synchronously to avoid a race
   // between extension loading and loading an URL from the command line.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   extension_path_ = base::MakeAbsoluteFilePath(path_in);
 
   if (!IsLoadingUnpackedAllowed()) {
     ReportExtensionLoadError(kUnpackedExtensionsBlacklistedError);
-    return;
+    return false;
   }
 
   std::string error;
   installer_.set_extension(extension_file_util::LoadExtension(
       extension_path_,
       Manifest::COMMAND_LINE,
       GetFlags(),
       &error));
 
   if (!installer_.extension()) {
     ReportExtensionLoadError(error);
-    return;
+    return false;
   }
 
-  launch_on_load_ = launch_on_load;
+  ShowInstallPrompt();
 
-  ShowInstallPrompt();
+  *extension_id = installer_.extension()->id();
+  return true;
 }
 
 void UnpackedInstaller::ShowInstallPrompt() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!service_weak_)
     return;
 
   const ExtensionSet* disabled_extensions =
       service_weak_->disabled_extensions();
   if (service_weak_->show_extensions_prompts() &&
@@ skipping 114 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   string16 error = installer_.CheckManagementPolicy();
   if (!error.empty()) {
     ReportExtensionLoadError(UTF16ToUTF8(error));
     return;
   }
 
   PermissionsUpdater perms_updater(service_weak_->profile());
   perms_updater.GrantActivePermissions(installer_.extension());
 
-  if (launch_on_load_)
-    service_weak_->ScheduleLaunchOnLoad(installer_.extension()->id());
-
   service_weak_->OnExtensionInstalled(
       installer_.extension(),
       syncer::StringOrdinal(),
       false /* no requirement errors */,
       false /* don't wait for idle */);
 }
 
 }  // namespace extensions