Change most content::URLFetcher references to net::URLFetcher

chrome/browser/component_updater/component_updater_service.cc

 // 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.
 
 #include "chrome/browser/component_updater/component_updater_service.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/at_exit.h"
@@ skipping 118 matching lines @@
   Del* delegate_;
   Ctx* context_;
 };
 // This function creates the right DelegateWithContext using template inference.
 template <typename Del, typename Ctx>
 net::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(content::URLFetcher* fetcher,
+void StartFetch(net::URLFetcher* fetcher,
                 net::URLRequestContextGetter* context_getter,
                 bool save_to_file) {
   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->SetAutomaticallyRetryOn5xx(false);
   if (save_to_file) {
     fetcher->SaveResponseToTemporaryFile(
@@ skipping 168 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<content::URLFetcher> url_fetcher_;
+  scoped_ptr<net::URLFetcher> url_fetcher_;
 
   typedef std::vector<CrxUpdateItem*> UpdateItems;
   UpdateItems work_items_;
 
   base::OneShotTimer<CrxUpdateService> timer_;
 
   Version chrome_version_;
 
   bool running_;
 
@@ skipping 161 matching lines @@
     CrxUpdateItem* item = *it;
     if (item->status != CrxUpdateItem::kCanUpdate)
       continue;
     // Found component to update, start the process.
     item->status = CrxUpdateItem::kDownloading;
     CRXContext* context = new CRXContext;
     context->pk_hash = item->component.pk_hash;
     context->id = item->id;
     context->installer = item->component.installer;
     url_fetcher_.reset(content::URLFetcher::Create(
-        0, item->crx_url, content::URLFetcher::GET,
+        0, item->crx_url, net::URLFetcher::GET,
         MakeContextDelegate(this, context)));
     StartFetch(url_fetcher_.get(), config_->RequestContext(), true);
     return;
   }
 
   std::string query;
   // If no pending upgrades, we check the if there are new
   // components we have not checked against the server. We
   // can batch a bunch in a single url request.
   for (UpdateItems::const_iterator it = work_items_.begin();
@@ skipping 40 matching lines @@
     // Next check after the long sleep.
     ScheduleNextRun(false);
     return;
   }
 
   // We got components to check. Start the url request.
   const std::string full_query = MakeFinalQuery(config_->UpdateUrl().spec(),
                                                 query,
                                                 config_->ExtraRequestParams());
   url_fetcher_.reset(content::URLFetcher::Create(
-      0, GURL(full_query), content::URLFetcher::GET,
+      0, GURL(full_query), net::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 net::URLFetcher* source,
                                           UpdateContext* context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (FetchSuccess(*source)) {
@@ skipping 187 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);
 }