Update the EphemeralAppLauncher for use by the webstorePrivate API

chrome/browser/apps/ephemeral_app_launcher.h

 // 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.
 
 #ifndef CHROME_BROWSER_APPS_EPHEMERAL_APP_LAUNCHER_H_
 #define CHROME_BROWSER_APPS_EPHEMERAL_APP_LAUNCHER_H_
 
 #include <string>
+#include <vector>
 
 #include "base/basictypes.h"
+#include "base/callback.h"
 #include "base/scoped_observer.h"
 #include "chrome/browser/extensions/webstore_standalone_installer.h"
 #include "chrome/browser/ui/extensions/extension_enable_flow_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 
 class ExtensionEnableFlow;
 class Profile;
 
 namespace content {
 class WebContents;
 }
 
 namespace extensions {
 class Extension;
+class ExtensionInstallChecker;
 class ExtensionRegistry;
 }
 
 // EphemeralAppLauncher manages the launching of ephemeral apps. It handles
 // display of a prompt, initiates install of the app (if necessary) and finally
 // launches the app.
 class EphemeralAppLauncher : public extensions::WebstoreStandaloneInstaller,
                              public content::WebContentsObserver,
                              public ExtensionEnableFlowDelegate {
  public:
-  typedef WebstoreStandaloneInstaller::Callback Callback;
+  // All possible result codes returned in the LaunchCallback.
+  enum LaunchResult {
+    // Successful launch.
+    LAUNCH_SUCCESS,
+    // Unknown or unspecified error.
+    LAUNCH_UNKNOWN_ERROR,
+    // Invalid extension ID for the app.
+    LAUNCH_INVALID_ID,
+    // An error occurred while parsing the app manifest.
+    LAUNCH_INVALID_MANIFEST,
+    // An error occurred while attempting to install the app ephemerally.
+    LAUNCH_INSTALL_ERROR,
+    // The user cancelled the launch.
+    LAUNCH_USER_CANCELLED,
+    // The feature is not available.
+    LAUNCH_FEATURE_DISABLED,
+    // The feature is not supported for the extension type.
+    LAUNCH_UNSUPPORTED_EXTENSION_TYPE,
+    // The app is blacklisted.
+    LAUNCH_BLACKLISTED,
+    // Unsatisfied dependencies (such as shared modules) or requirements.
+    LAUNCH_MISSING_DEPENDENCIES,
+    // The app is blocked by management policies.
+    LAUNCH_BLOCKED_BY_POLICY

[asargent_no_longer_on_chrome, 2014/06/18 20:25:10]

Hmm, this enum seems to have a lot of overlap with the InstallResult enum in
WebstoreStandaloneInstaller. Would it make sense to re-use the InstallResult
ones and only have the ones unique to launching here? Or maybe have a common
place where all the common ones are listed with a name that is more generic?
e.g.

namespace extensions {
namespace webstore_install {

enum InstallOrLaunchResult {
  SUCCESS,
  UNKNOWN_ERROR,
  INVALID_ID,
  INVALID_MANIFEST,
  etc...
};


}
}

[tmdiep, 2014/06/18 22:28:34]

I went back and forth with this issue a fair bit. The problem is that launch
result is a superset of install result, but unfortunately you can't inherit
enums. What do you think about returning an int error code instead of enum from
all the installers. Then subclasses can add extra codes.

[asargent_no_longer_on_chrome, 2014/06/19 00:16:43]

I think it might be ok to have a single enum somewhere in a shared header file
with all the various codes, and the common ones don't have any prefix (eg
SUCCESS, UNKNOWN_ERROR) and the specific ones might (eg
LAUNCH_FEATURE_DISABLED). 

+  };
+
+  typedef base::Callback<void(LaunchResult result, const std::string& error)>
+      LaunchCallback;
+
+  // Returns true if launching ephemeral apps is enabled.
+  static bool IsFeatureEnabled();
 
   // Create for the app launcher.
   static scoped_refptr<EphemeralAppLauncher> CreateForLauncher(
       const std::string& webstore_item_id,
       Profile* profile,
       gfx::NativeWindow parent_window,
-      const Callback& callback);
+      const LaunchCallback& callback);
 
-  // Create for a link within a browser tab.
-  static scoped_refptr<EphemeralAppLauncher> CreateForLink(
+  // Create for a web contents.
+  static scoped_refptr<EphemeralAppLauncher> CreateForWebContents(
       const std::string& webstore_item_id,
-      content::WebContents* web_contents);
+      content::WebContents* web_contents,
+      const LaunchCallback& callback);
 
   // Initiate app launch.
   void Start();
 
- private:
-  friend class base::RefCountedThreadSafe<EphemeralAppLauncher>;
-
+ protected:
   EphemeralAppLauncher(const std::string& webstore_item_id,
                        Profile* profile,
                        gfx::NativeWindow parent_window,
-                       const Callback& callback);
+                       const LaunchCallback& callback);
   EphemeralAppLauncher(const std::string& webstore_item_id,
                        content::WebContents* web_contents,
-                       const Callback& callback);
+                       const LaunchCallback& callback);
 
   virtual ~EphemeralAppLauncher();
 
+  // Returns true if an app that is already installed in extension system can
+  // be launched.
+  bool CanLaunchInstalledApp(const extensions::Extension* extension,
+                             LaunchResult* reason,
+                             std::string* error);
+
+  // Initiates the enable flow for an app before it can be launched.
+  void EnableInstalledApp(const extensions::Extension* extension);
+
+  // After the ephemeral installation or enable flow are complete, attempts to
+  // launch the app and notify the client of the outcome.
+  void MaybeLaunchApp();
+
+  // Launches an app. At this point, it is assumed that the app is enabled and
+  // can be launched.
   void LaunchApp(const extensions::Extension* extension) const;
 
+  // Notifies the client of the launch outcome.
+  void InvokeCallback(LaunchResult result, const std::string& error);
+
+  // Aborts the ephemeral install and notifies the client of the outcome.
+  void AbortLaunch(LaunchResult result, const std::string& error);
+
+  // Creates an install checker. Allows tests to mock the install checker.
+  virtual scoped_ptr<extensions::ExtensionInstallChecker>
+      CreateInstallChecker();
+
+  // Determines whether the app can be installed ephemerally.
+  void CheckEphemeralInstallPermitted();
+
+  // Install checker callback.
+  void OnInstallChecked(int check_failures);
+
   // WebstoreStandaloneInstaller implementation.
   virtual bool CheckRequestorAlive() const OVERRIDE;
   virtual const GURL& GetRequestorURL() const OVERRIDE;
   virtual bool ShouldShowPostInstallUI() const OVERRIDE;
   virtual bool ShouldShowAppInstalledBubble() const OVERRIDE;
   virtual content::WebContents* GetWebContents() const OVERRIDE;
   virtual scoped_ptr<ExtensionInstallPrompt::Prompt>
       CreateInstallPrompt() const OVERRIDE;
   virtual bool CheckInlineInstallPermitted(
       const base::DictionaryValue& webstore_data,
       std::string* error) const OVERRIDE;
   virtual bool CheckRequestorPermitted(
       const base::DictionaryValue& webstore_data,
       std::string* error) const OVERRIDE;
-  virtual bool CheckInstallValid(
-      const base::DictionaryValue& manifest,
-      std::string* error) OVERRIDE;
+  virtual void OnManifestParsed() OVERRIDE;
   virtual scoped_ptr<ExtensionInstallPrompt> CreateInstallUI() OVERRIDE;
   virtual scoped_ptr<extensions::WebstoreInstaller::Approval>
       CreateApproval() const OVERRIDE;
-  virtual void CompleteInstall(const std::string& error) OVERRIDE;
+  virtual void CompleteInstall(InstallResult result,
+                               const std::string& error) OVERRIDE;
 
   // content::WebContentsObserver implementation.
   virtual void WebContentsDestroyed() OVERRIDE;
 
   // ExtensionEnableFlowDelegate implementation.
   virtual void ExtensionEnableFlowFinished() OVERRIDE;
   virtual void ExtensionEnableFlowAborted(bool user_initiated) OVERRIDE;
 
+ private:
+  friend class base::RefCountedThreadSafe<EphemeralAppLauncher>;
+  friend class EphemeralAppLauncherTest;
+
+  LaunchCallback launch_callback_;
+
   gfx::NativeWindow parent_window_;
   scoped_ptr<content::WebContents> dummy_web_contents_;
 
-  // Created in CheckInstallValid().
-  scoped_refptr<extensions::Extension> extension_;
+  scoped_ptr<ExtensionEnableFlow> extension_enable_flow_;
 
-  scoped_ptr<ExtensionEnableFlow> extension_enable_flow_;
+  scoped_ptr<extensions::ExtensionInstallChecker> install_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(EphemeralAppLauncher);
 };
 
 #endif  // CHROME_BROWSER_APPS_EPHEMERAL_APP_LAUNCHER_H_