Create a content::UrlFetcher interface that lives in content/public/common and convert users to i...

chrome/browser/component_updater/component_updater_service.cc

 // Copyright (c) 2011 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/component_updater/component_updater_service.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/at_exit.h"
@@ skipping 84 matching lines @@
 
 // Helper template class that allows our main class to have separate
 // OnURLFetchComplete() callbacks for diffent types of url requests
 // they are differentiated by the |Ctx| type.
 template <typename Del, typename Ctx>
 class DelegateWithContext : public content::URLFetcherDelegate {
  public:
   DelegateWithContext(Del* delegate, Ctx* context)
     : delegate_(delegate), context_(context) {}
 
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE {
+  virtual void OnURLFetchComplete(const content::URLFetcher* source) OVERRIDE {
     delegate_->OnURLFetchComplete(source, context_);
     delete this;
   }
 
  private:
   ~DelegateWithContext() {}
 
   Del* delegate_;
   Ctx* context_;
 };
 // This function creates the right DelegateWithContext using template inference.
 template <typename Del, typename Ctx>
 content::URLFetcherDelegate* MakeContextDelegate(Del* delegate, Ctx* context) {
   return new DelegateWithContext<Del, Ctx>(delegate, context);
 }
 
 // Helper to start a url request using |fetcher| with the common flags.
-void StartFetch(URLFetcher* fetcher,
+void StartFetch(content::URLFetcher* fetcher,
                 net::URLRequestContextGetter* context_getter,
                 bool save_to_file) {
-  fetcher->set_request_context(context_getter);
-  fetcher->set_load_flags(net::LOAD_DO_NOT_SEND_COOKIES |
-                          net::LOAD_DO_NOT_SAVE_COOKIES |
-                          net::LOAD_DISABLE_CACHE);
+  fetcher->SetRequestContext(context_getter);
+  fetcher->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
+                        net::LOAD_DO_NOT_SAVE_COOKIES |
+                        net::LOAD_DISABLE_CACHE);
   // TODO(cpu): Define our retry and backoff policy.
-  fetcher->set_automatically_retry_on_5xx(false);
+  fetcher->SetAutomaticallyRetryOn5xx(false);
   if (save_to_file) {
     fetcher->SaveResponseToTemporaryFile(
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
   }
   fetcher->Start();
 }
 
 // Returs true if the url request of |fetcher| was succesful.
-bool FetchSuccess(const URLFetcher& fetcher) {
-  return (fetcher.status().status() == net::URLRequestStatus::SUCCESS) &&
-         (fetcher.response_code() == 200);
+bool FetchSuccess(const content::URLFetcher& fetcher) {
+  return (fetcher.GetStatus().status() == net::URLRequestStatus::SUCCESS) &&
+         (fetcher.GetResponseCode() == 200);
 }
 
 // This is the one and only per-item state structure. Designed to be hosted
 // in a std::vector or a std::list. The two main members are |component|
 // which is supplied by the the component updater client and |status| which
 // is modified as the item is processed by the update pipeline. The expected
 // transition graph is:
 //                                error          error         error
 //              +--kNoUpdate<------<-------+------<------+------<------+
 //              |                          |             |             |
@@ skipping 112 matching lines @@
   };
 
   // Context for a crx download url request. See DelegateWithContext above.
   struct CRXContext {
     ComponentInstaller* installer;
     std::vector<uint8> pk_hash;
     std::string id;
     CRXContext() : installer(NULL) {}
   };
 
-  void OnURLFetchComplete(const URLFetcher* source, UpdateContext* context);
+  void OnURLFetchComplete(const content::URLFetcher* source,
+                          UpdateContext* context);
 
-  void OnURLFetchComplete(const URLFetcher* source, CRXContext* context);
+  void OnURLFetchComplete(const content::URLFetcher* source,
+                          CRXContext* context);
 
  private:
   // See ManifestParserBridge.
   void OnParseUpdateManifestSucceeded(
       const UpdateManifest::Results& results);
 
   // See ManifestParserBridge.
   void OnParseUpdateManifestFailed(
       const std::string& error_message);
 
@@ skipping 10 matching lines @@
   void DoneInstalling(const std::string& component_id,
                       ComponentUnpacker::Error error);
 
   size_t ChangeItemStatus(CrxUpdateItem::Status from,
                           CrxUpdateItem::Status to);
 
   CrxUpdateItem* FindUpdateItemById(const std::string& id);
 
   scoped_ptr<Config> config_;
 
-  scoped_ptr<URLFetcher> url_fetcher_;
+  scoped_ptr<content::URLFetcher> url_fetcher_;
 
   typedef std::vector<CrxUpdateItem*> UpdateItems;
   UpdateItems work_items_;
 
   base::OneShotTimer<CrxUpdateService> timer_;
 
   Version chrome_version_;
 
   bool running_;
 
@@ skipping 231 matching lines @@
   const std::string full_query = MakeFinalQuery(config_->UpdateUrl().spec(),
                                                 query,
                                                 config_->ExtraRequestParams());
   url_fetcher_.reset(URLFetcher::Create(0, GURL(full_query), URLFetcher::GET,
       MakeContextDelegate(this, new UpdateContext())));
   StartFetch(url_fetcher_.get(), config_->RequestContext(), false);
 }
 
 // Caled when we got a response from the update server. It consists of an xml
 // document following the omaha update scheme.
-void CrxUpdateService::OnURLFetchComplete(const URLFetcher* source,
+void CrxUpdateService::OnURLFetchComplete(const content::URLFetcher* source,
                                           UpdateContext* context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (FetchSuccess(*source)) {
     std::string xml;
     source->GetResponseAsString(&xml);
     url_fetcher_.reset();
     ParseManifest(xml);
   } else {
     url_fetcher_.reset();
     CrxUpdateService::OnParseUpdateManifestFailed("network error");
@@ skipping 84 matching lines @@
   size_t count = ChangeItemStatus(CrxUpdateItem::kChecking,
                                   CrxUpdateItem::kNoUpdate);
   config_->OnEvent(Configurator::kManifestError, static_cast<int>(count));
   DCHECK_GT(count, 0ul);
   ScheduleNextRun(false);
 }
 
 // Called when the CRX package has been downloaded to a temporary location.
 // Here we fire the notifications and schedule the component-specific installer
 // to be called in the file thread.
-void CrxUpdateService::OnURLFetchComplete(const URLFetcher* source,
+void CrxUpdateService::OnURLFetchComplete(const content::URLFetcher* source,
                                           CRXContext* context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::PlatformFileError error_code;
 
   if (source->FileErrorOccurred(&error_code) || !FetchSuccess(*source)) {
     size_t count = ChangeItemStatus(CrxUpdateItem::kDownloading,
                                     CrxUpdateItem::kNoUpdate);
     DCHECK_EQ(count, 1ul);
     config_->OnEvent(Configurator::kNetworkError, CrxIdtoUMAId(context->id));
     url_fetcher_.reset();
@@ skipping 68 matching lines @@
   ScheduleNextRun(false);
 }
 
 // The component update factory. Using the component updater as a singleton
 // is the job of the browser process.
 ComponentUpdateService* ComponentUpdateServiceFactory(
     ComponentUpdateService::Configurator* config) {
   DCHECK(config);
   return new CrxUpdateService(config);
 }