Update the EphemeralAppLauncher for use by the webstorePrivate API

chrome/browser/extensions/webstore_standalone_installer.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_WEBSTORE_STANDALONE_INSTALLER_H_
 #define CHROME_BROWSER_EXTENSIONS_WEBSTORE_STANDALONE_INSTALLER_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/webstore_data_fetcher_delegate.h"
 #include "chrome/browser/extensions/webstore_install_helper.h"
+#include "chrome/browser/extensions/webstore_install_result.h"
 #include "chrome/browser/extensions/webstore_installer.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 class GURL;
 
 namespace base {
 class DictionaryValue;
 }
 
@@ skipping 27 matching lines @@
   typedef base::Callback<void(bool success, const std::string& error)> Callback;
 
   WebstoreStandaloneInstaller(const std::string& webstore_item_id,
                               Profile* profile,
                               const Callback& callback);
   void BeginInstall();
 
  protected:
   virtual ~WebstoreStandaloneInstaller();
 
+  // Called when the install should be aborted. The callback is cleared.
   void AbortInstall();
-  void InvokeCallback(const std::string& error);
-  virtual void CompleteInstall(const std::string& error);
+
+  // Called when the install is complete.
+  virtual void CompleteInstall(webstore_install::Result result,
+                               const std::string& error);
+
+  // Called when the installer should proceed to prompt the user.
+  void ProceedWithInstallPrompt();
+
+  // Lazily creates a dummy extension for display from the parsed manifest. This
+  // is safe to call from OnManifestParsed() onwards. The manifest may be
+  // invalid, thus the caller must check that the return value is not NULL.
+  scoped_refptr<const Extension> GetLocalizedExtensionForDisplay();
 
   // Template Method's hooks to be implemented by subclasses.
 
   // Called at certain check points of the workflow to decide whether it makes
   // sense to proceed with installation. A requestor can be a website that
   // initiated an inline installation, or a command line option.
   virtual bool CheckRequestorAlive() const = 0;
 
   // Requestor's URL, if any. Should be an empty GURL if URL is meaningless
   // (e.g. for a command line option).
@@ skipping 25 matching lines @@
       const base::DictionaryValue& webstore_data,
       std::string* error) const = 0;
 
   // Perform all necessary checks to make sure that requestor is allowed to
   // initiate this install (e.g. that the requestor's URL matches the verified
   // author's site specified in the extension's properties in the store).
   virtual bool CheckRequestorPermitted(
       const base::DictionaryValue& webstore_data,
       std::string* error) const = 0;
 
-  // Perform all necessary checks after the manifest has been parsed to make
-  // sure that the install should still proceed.
-  virtual bool CheckInstallValid(
-      const base::DictionaryValue& manifest,
-      std::string* error);
+  // Will be called after the extension's manifest has been successfully parsed.
+  // Subclasses can perform asynchronous checks at this point and call
+  // ProceedWithInstallPrompt() to proceed with the install or otherwise call
+  // CompleteInstall() with an error code. The default implementation calls
+  // ProceedWithInstallPrompt().
+  virtual void OnManifestParsed();
 
   // Returns an install UI to be shown. By default, this returns an install UI
   // that is a transient child of the host window for GetWebContents().
   virtual scoped_ptr<ExtensionInstallPrompt> CreateInstallUI();
 
   // Create an approval to pass installation parameters to the CrxInstaller.
   virtual scoped_ptr<WebstoreInstaller::Approval> CreateApproval() const;
 
   // Accessors to be used by subclasses.
   bool show_user_count() const { return show_user_count_; }
   const std::string& localized_user_count() const {
     return localized_user_count_;
   }
   double average_rating() const { return average_rating_; }
   int rating_count() const { return rating_count_; }
   void set_install_source(WebstoreInstaller::InstallSource source) {
     install_source_ = source;
   }
   WebstoreInstaller::InstallSource install_source() const {
     return install_source_;
   }
   Profile* profile() const { return profile_; }
   const std::string& id() const { return id_; }
   const base::DictionaryValue* manifest() const { return manifest_.get(); }
+  const Extension* localized_extension_for_display() const {
+    return localized_extension_for_display_.get();
+  }
 
  private:
   friend class base::RefCountedThreadSafe<WebstoreStandaloneInstaller>;
   FRIEND_TEST_ALL_PREFIXES(WebstoreStandaloneInstallerTest, DomainVerification);
 
   // Several delegate/client interface implementations follow. The normal flow
   // (for successful installs) is:
   //
   // 1. BeginInstall: starts the fetch of data from the webstore
   // 2. OnURLFetchComplete: starts the parsing of data from the webstore
@@ skipping 65 matching lines @@
   // Created by ShowInstallUI() when a prompt is shown (if
   // the implementor returns a non-NULL in CreateInstallPrompt()).
   scoped_refptr<Extension> localized_extension_for_display_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(WebstoreStandaloneInstaller);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_WEBSTORE_STANDALONE_INSTALLER_H_