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 "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 {
  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 49 matching lines @@
 
   // We need to keep track of some information associated with a url
   // when doing a fetch.
   struct ExtensionFetch {
     ExtensionFetch();
     ExtensionFetch(const std::string& id, const GURL& url,
                    const std::string& package_hash, const std::string& version,
                    const std::set<int>& request_ids);
     ~ExtensionFetch();
 
+    // Potentially updates this fetch'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 IterateCredentialsAfterFailure(const net::URLRequestStatus& status,
+                                        int response_code,
+                                        bool support_oauth2);
+
     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);
 
+  // Receives an OAuth2 token to authenticate a Webstore CRX fetch.
+  void OnWebstoreOAuth2TokenReceived(bool success, const std::string& token);
+
   // 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_;
 
+  // Acquires access tokens for webstore download URLs.
+  scoped_ptr<WebstoreOAuth2TokenProvider> webstore_token_provider_;
+
   DISALLOW_COPY_AND_ASSIGN(ExtensionDownloader);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_UPDATER_EXTENSION_DOWNLOADER_H_