OAuth2 support for Webstore downloads.

chrome/browser/extensions/updater/extension_downloader.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_UPDATER_EXTENSION_DOWNLOADER_H_
 #define CHROME_BROWSER_EXTENSIONS_UPDATER_EXTENSION_DOWNLOADER_H_
 
 #include <deque>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/version.h"
 #include "chrome/browser/extensions/updater/extension_downloader_delegate.h"
 #include "chrome/browser/extensions/updater/manifest_fetch_data.h"
 #include "chrome/browser/extensions/updater/request_queue.h"
 #include "chrome/common/extensions/update_manifest.h"
 #include "extensions/common/extension.h"
+#include "google_apis/gaia/oauth2_token_service.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "url/gurl.h"
 
+class IdentityProvider;
+
 namespace net {
 class URLFetcher;
 class URLRequestContextGetter;
 class URLRequestStatus;
 }
 
 namespace extensions {
 
 struct UpdateDetails {
   UpdateDetails(const std::string& id, const base::Version& version);
   ~UpdateDetails();
 
   std::string id;
   base::Version version;
 };
 
 class ExtensionCache;
 class ExtensionUpdaterTest;
+class WebstoreOAuth2TokenProvider;
 
 // A class that checks for updates of a given list of extensions, and downloads
 // the crx file when updates are found. It uses a |ExtensionDownloaderDelegate|
 // that takes ownership of the downloaded crx files, and handles events during
 // the update check.
-class ExtensionDownloader : public net::URLFetcherDelegate {
+class ExtensionDownloader
+    : public net::URLFetcherDelegate,
+      public OAuth2TokenService::Consumer {
  public:
   // |delegate| is stored as a raw pointer and must outlive the
-  // ExtensionDownloader.
+  // ExtensionDownloader. |webstore_identity_provider| may be NULL if this
+  // ExtensionDownloader does not need OAuth2 support; if not NULL, the
+  // given IdentityProvider must outlive this ExtensionDownloader.
   ExtensionDownloader(ExtensionDownloaderDelegate* delegate,
-                      net::URLRequestContextGetter* request_context);
+                      net::URLRequestContextGetter* request_context,
+                      IdentityProvider* webstore_identity_provider);
   virtual ~ExtensionDownloader();
 
   // Adds |extension| to the list of extensions to check for updates.
   // Returns false if the |extension| can't be updated due to invalid details.
   // In that case, no callbacks will be performed on the |delegate_|.
   // The |request_id| is passed on as is to the various |delegate_| callbacks.
   // This is used for example by ExtensionUpdater to keep track of when
   // potentially concurrent update checks complete.
   bool AddExtension(const Extension& extension, int request_id);
 
@@ skipping 55 matching lines @@
                    const std::string& package_hash, const std::string& version,
                    const std::set<int>& request_ids);
     ~ExtensionFetch();
 
     std::string id;
     GURL url;
     std::string package_hash;
     std::string version;
     std::set<int> request_ids;
 
-    // Indicates whether or not the fetch is known to require credentials.
-    bool is_protected;
+    enum CredentialsMode {
+      CREDENTIALS_NONE = 0,
+      CREDENTIALS_OAUTH2_TOKEN,
+      CREDENTIALS_COOKIES,
+    };
+
+    // Indicates the type of credentials to include with this fetch.
+    CredentialsMode credentials;
   };
 
   // Helper for AddExtension() and AddPendingExtension().
   bool AddExtensionData(const std::string& id,
                         const base::Version& version,
                         Manifest::Type extension_type,
                         const GURL& extension_update_url,
                         const std::string& update_url_data,
                         int request_id);
 
@@ skipping 52 matching lines @@
 
   // Do real work of StartAllPending. If .crx cache is used, this function
   // is called when cache is ready.
   void DoStartAllPending();
 
   // Notify delegate and remove ping results.
   void NotifyDelegateDownloadFinished(scoped_ptr<ExtensionFetch> fetch_data,
                                       const base::FilePath& crx_path,
                                       bool file_ownership_passed);
 
+  // Potentially updates an ExtensionFetch's authentication state and returns
+  // |true| if the fetch should be retried. Returns |false| if the failure was
+  // not related to authentication, leaving the ExtensionFetch data unmodified.
+  bool IterateFetchCredentialsAfterFailure(ExtensionFetch* fetch,
+                                           const net::URLRequestStatus& status,
+                                           int response_code);
+
+  // OAuth2TokenService::Consumer implementation.
+  virtual void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
+                                 const std::string& access_token,
+                                 const base::Time& expiration_time) OVERRIDE;
+  virtual void OnGetTokenFailure(const OAuth2TokenService::Request* request,
+                                 const GoogleServiceAuthError& error) OVERRIDE;
+
   // The delegate that receives the crx files downloaded by the
   // ExtensionDownloader, and that fills in optional ping and update url data.
   ExtensionDownloaderDelegate* delegate_;
 
   // The request context to use for the URLFetchers.
   scoped_refptr<net::URLRequestContextGetter> request_context_;
 
   // Used to create WeakPtrs to |this|.
   base::WeakPtrFactory<ExtensionDownloader> weak_ptr_factory_;
 
@@ skipping 16 matching lines @@
   // is available.
   RequestQueue<ManifestFetchData> manifests_queue_;
   RequestQueue<ExtensionFetch> extensions_queue_;
 
   // Maps an extension-id to its PingResult data.
   std::map<std::string, ExtensionDownloaderDelegate::PingResult> ping_results_;
 
   // Cache for .crx files.
   ExtensionCache* extension_cache_;
 
+  // An IdentityProvider which may be used for authentication on protected
+  // download requests. May be NULL.
+  IdentityProvider* identity_provider_;
+
+  // A Webstore download-scoped access token for the
+  // |webstore_identity_provider_|'s active account, if any.
+  std::string access_token_;
+
+  // A pending token fetch request.
+  scoped_ptr<OAuth2TokenService::Request> access_token_request_;
+
   DISALLOW_COPY_AND_ASSIGN(ExtensionDownloader);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_UPDATER_EXTENSION_DOWNLOADER_H_