Remove --install-from-webstore and --limited-install-from-webstore

chrome/browser/extensions/startup_helper.cc

 // 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.
 
 #include "chrome/browser/extensions/startup_helper.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 16 matching lines @@
 
 #if defined(OS_WIN)
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_util.h"
 #endif
 
 using content::BrowserThread;
 
+namespace extensions {
+
 namespace {
 
 void PrintPackExtensionMessage(const std::string& message) {
   VLOG(1) << message;
 }
 
 // On Windows, the jumplist action for installing an ephemeral app has to use
-// the --install-from-webstore command line arg to initiate an install.
-scoped_refptr<extensions::WebstoreStandaloneInstaller>
-CreateEphemeralAppInstaller(
+// the --install-ephemeral-app-from-webstore command line arg to initiate an
+// install.
+scoped_refptr<WebstoreStandaloneInstaller> CreateEphemeralAppInstaller(
     Profile* profile,
     const std::string& app_id,
-    extensions::WebstoreStandaloneInstaller::Callback callback) {
-  scoped_refptr<extensions::WebstoreStandaloneInstaller> installer;
+    WebstoreStandaloneInstaller::Callback callback) {
+  scoped_refptr<WebstoreStandaloneInstaller> installer;
 
 #if defined(OS_WIN)
-  using extensions::ExtensionRegistry;
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile);
   DCHECK(registry);
   if (!registry->GetExtensionById(app_id, ExtensionRegistry::EVERYTHING) ||
-      !extensions::util::IsEphemeralApp(app_id, profile)) {
+      !util::IsEphemeralApp(app_id, profile)) {
     return installer;
   }
 
-  extensions::AppWindowRegistry* app_window_registry =
-      extensions::AppWindowRegistry::Get(profile);
+  AppWindowRegistry* app_window_registry = AppWindowRegistry::Get(profile);
   DCHECK(app_window_registry);
-  extensions::AppWindow* app_window =
+  AppWindow* app_window =
       app_window_registry->GetCurrentAppWindowForApp(app_id);
   if (!app_window)
     return installer;
 
-  installer = new extensions::WebstoreInstallWithPrompt(
+  installer = new WebstoreInstallWithPrompt(
       app_id, profile, app_window->GetNativeWindow(), callback);
 #endif
 
   return installer;
 }
 
 }  // namespace
 
-namespace extensions {
-
 StartupHelper::StartupHelper() : pack_job_succeeded_(false) {
   ExtensionsClient::Set(ChromeExtensionsClient::GetInstance());
 }
 
 void StartupHelper::OnPackSuccess(
     const base::FilePath& crx_path,
     const base::FilePath& output_private_key_path) {
   pack_job_succeeded_ = true;
   PrintPackExtensionMessage(
       base::UTF16ToUTF8(
@@ skipping 191 matching lines @@
     const std::string& id,
     bool show_prompt,
     DoneCallback done_callback) {
   done_callback_ = done_callback;
 
   WebstoreStandaloneInstaller::Callback callback =
       base::Bind(&AppInstallHelper::OnAppInstallComplete,
                  base::Unretained(this));
 
   installer_ = CreateEphemeralAppInstaller(profile, id, callback);
-  if (!installer_.get()) {
-    installer_ =
-        new WebstoreStartupInstaller(id, profile, show_prompt, callback);
+  if (installer_.get()) {
+    installer_->BeginInstall();
+  } else {
+    error_ = "Not a supported ephemeral app installation.";
+    done_callback_.Run();
   }
-  installer_->BeginInstall();
 }
 
 void AppInstallHelper::OnAppInstallComplete(bool success,
                                             const std::string& error,
                                             webstore_install::Result result) {
   success_ = success;
   error_= error;
   done_callback_.Run();
 }
 
-void DeleteHelperAndRunCallback(AppInstallHelper* helper,
-                                base::Callback<void()> callback) {
-  delete helper;
-  callback.Run();
-}
-
 }  // namespace
 
-bool StartupHelper::InstallFromWebstore(const CommandLine& cmd_line,
+bool StartupHelper::InstallEphemeralApp(const CommandLine& cmd_line,
                                         Profile* profile) {
-  std::string id = cmd_line.GetSwitchValueASCII(switches::kInstallFromWebstore);
+  std::string id =
+      cmd_line.GetSwitchValueASCII(switches::kInstallEphemeralAppFromWebstore);
   if (!crx_file::id_util::IdIsValid(id)) {
-    LOG(ERROR) << "Invalid id for " << switches::kInstallFromWebstore
-               << " : '" << id << "'";
+    LOG(ERROR) << "Invalid id for "
+        << switches::kInstallEphemeralAppFromWebstore << " : '" << id << "'";
     return false;
   }
 
   AppInstallHelper helper;
   base::RunLoop run_loop;
   helper.BeginInstall(profile, id, true, run_loop.QuitClosure());
   run_loop.Run();
 
   if (!helper.success())
     LOG(ERROR) << "InstallFromWebstore failed with error: " << helper.error();
   return helper.success();
 }
 
-void StartupHelper::LimitedInstallFromWebstore(
-    const CommandLine& cmd_line,
-    Profile* profile,
-    base::Callback<void()> done_callback) {
-  std::string id = WebStoreIdFromLimitedInstallCmdLine(cmd_line);
-  if (!crx_file::id_util::IdIsValid(id)) {
-    LOG(ERROR) << "Invalid index for " << switches::kLimitedInstallFromWebstore;
-    done_callback.Run();
-    return;
-  }
-
-  AppInstallHelper* helper = new AppInstallHelper();
-  helper->BeginInstall(profile, id, false /*show_prompt*/,
-                       base::Bind(&DeleteHelperAndRunCallback,
-                                  helper, done_callback));
-}
-
-std::string StartupHelper::WebStoreIdFromLimitedInstallCmdLine(
-    const CommandLine& cmd_line) {
-  std::string index = cmd_line.GetSwitchValueASCII(
-      switches::kLimitedInstallFromWebstore);
-  std::string id;
-  if (index == "1") {
-    id = "nckgahadagoaajjgafhacjanaoiihapd";
-  } else if (index == "2") {
-    id = "ecglahbcnmdpdciemllbhojghbkagdje";
-  }
-  return id;
-}
-
 StartupHelper::~StartupHelper() {
   if (pack_job_.get())
     pack_job_->ClearClient();
 }
 
 }  // namespace extensions