Introduce a stable set of errors for inline install

chrome/browser/apps/ephemeral_app_launcher.cc

 // Copyright 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/apps/ephemeral_app_launcher.h"
 
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_install_checker.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
@@ skipping 114 matching lines @@
                    kFeatureDisabledError);
     return;
   }
 
   // Check whether the app already exists in extension system before downloading
   // from the webstore.
   const Extension* extension =
       ExtensionRegistry::Get(profile())
           ->GetExtensionById(id(), ExtensionRegistry::EVERYTHING);
   if (extension) {
-    webstore_install::Result result = webstore_install::UNKNOWN_ERROR;
+    webstore_install::Result result = webstore_install::OTHER_ERROR;
     std::string error;
     if (!CanLaunchInstalledApp(extension, &result, &error)) {
       InvokeCallback(result, error);
       return;
     }
 
     if (extensions::util::IsAppLaunchableWithoutEnabling(extension->id(),
                                                          profile())) {
       LaunchApp(extension);
       InvokeCallback(webstore_install::SUCCESS, std::string());
@@ skipping 72 matching lines @@
     *reason = webstore_install::REQUIREMENT_VIOLATIONS;
     *error = kRequirementsError;
     return false;
   }
 
   return true;
 }
 
 void EphemeralAppLauncher::EnableInstalledApp(const Extension* extension) {
   // Check whether an install is already in progress.
-  webstore_install::Result result = webstore_install::UNKNOWN_ERROR;
+  webstore_install::Result result = webstore_install::OTHER_ERROR;
   std::string error;
   if (!EnsureUniqueInstall(&result, &error)) {
     InvokeCallback(result, error);
     return;
   }
 
   // Keep this object alive until the enable flow is complete. Either
   // ExtensionEnableFlowFinished() or ExtensionEnableFlowAborted() will be
   // called.
   AddRef();
 
   extension_enable_flow_.reset(
       new ExtensionEnableFlow(profile(), extension->id(), this));
   if (web_contents())
     extension_enable_flow_->StartForWebContents(web_contents());
   else
     extension_enable_flow_->StartForNativeWindow(parent_window_);
 }
 
 void EphemeralAppLauncher::MaybeLaunchApp() {
-  webstore_install::Result result = webstore_install::UNKNOWN_ERROR;
+  webstore_install::Result result = webstore_install::OTHER_ERROR;
   std::string error;
 
   ExtensionRegistry* registry = ExtensionRegistry::Get(profile());
   const Extension* extension =
       registry->GetExtensionById(id(), ExtensionRegistry::EVERYTHING);
   if (extension) {
     // Although the installation was successful, the app may not be
     // launchable.
     if (registry->enabled_extensions().Contains(extension->id())) {
       result = webstore_install::SUCCESS;
@@ skipping 62 matching lines @@
   install_checker_->set_extension(extension);
   install_checker_->Start(ExtensionInstallChecker::CHECK_BLACKLIST |
                               ExtensionInstallChecker::CHECK_REQUIREMENTS,
                           true,
                           base::Bind(&EphemeralAppLauncher::OnInstallChecked,
                                      base::Unretained(this)));
 }
 
 void EphemeralAppLauncher::OnInstallChecked(int check_failures) {
   if (!CheckRequestorAlive()) {
-    AbortLaunch(webstore_install::UNKNOWN_ERROR, std::string());
+    AbortLaunch(webstore_install::OTHER_ERROR, std::string());
     return;
   }
 
   if (install_checker_->blacklist_state() == extensions::BLACKLISTED_MALWARE) {
     AbortLaunch(webstore_install::BLACKLISTED, kBlacklistedError);
     return;
   }
 
   if (!install_checker_->requirement_errors().empty()) {
     AbortLaunch(webstore_install::REQUIREMENT_VIOLATIONS,
@@ skipping 60 matching lines @@
   return true;
 }
 
 void EphemeralAppLauncher::OnManifestParsed() {
   const Extension* extension = GetLocalizedExtensionForDisplay();
   if (!extension) {
     AbortLaunch(webstore_install::INVALID_MANIFEST, kInvalidManifestError);
     return;
   }
 
-  webstore_install::Result result = webstore_install::UNKNOWN_ERROR;
+  webstore_install::Result result = webstore_install::OTHER_ERROR;
   std::string error;
   if (!CheckCommonLaunchCriteria(profile(), extension, &result, &error)) {
     AbortLaunch(result, error);
     return;
   }
 
   if (extension->is_legacy_packaged_app()) {
     AbortLaunch(webstore_install::LAUNCH_UNSUPPORTED_EXTENSION_TYPE,
                 kAppTypeError);
     return;
@@ skipping 32 matching lines @@
 
   // CompleteInstall will call Release.
   WebstoreStandaloneInstaller::CompleteInstall(webstore_install::SUCCESS,
                                                std::string());
 }
 
 void EphemeralAppLauncher::ExtensionEnableFlowAborted(bool user_initiated) {
   // CompleteInstall will call Release.
   CompleteInstall(webstore_install::USER_CANCELLED, kUserCancelledError);
 }