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

chrome/browser/extensions/extension_updater.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/extensions/extension_updater.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 573 matching lines @@
   profile_ = NULL;
   timer_.Stop();
   will_check_soon_ = false;
   manifest_fetcher_.reset();
   extension_fetcher_.reset();
   STLDeleteElements(&manifests_pending_);
   manifests_pending_.clear();
   extensions_pending_.clear();
 }
 
-void ExtensionUpdater::OnURLFetchComplete(const URLFetcher* source) {
+void ExtensionUpdater::OnURLFetchComplete(const content::URLFetcher* source) {
   // Stop() destroys all our URLFetchers, which means we shouldn't be
   // called after Stop() is called.
   DCHECK(alive_);
 
   if (source == manifest_fetcher_.get()) {
     std::string data;
     source->GetResponseAsString(&data);
-    OnManifestFetchComplete(source->url(),
-                            source->status(),
-                            source->response_code(),
+    OnManifestFetchComplete(source->GetUrl(),
+                            source->GetStatus(),
+                            source->GetResponseCode(),
                             data);
   } else if (source == extension_fetcher_.get()) {
     OnCRXFetchComplete(source,
-                       source->url(),
-                       source->status(),
-                       source->response_code());
+                       source->GetUrl(),
+                       source->GetStatus(),
+                       source->GetResponseCode());
   } else {
     NOTREACHED();
   }
   NotifyIfFinished();
 }
 
 // Utility class to handle doing xml parsing in a sandboxed utility process.
 class SafeManifestParser : public UtilityProcessHost::Client {
  public:
   // Takes ownership of |fetch_data|.
@@ skipping 198 matching lines @@
   // Tell ExtensionService to update prefs.
   service_->UpdateExtensionBlacklist(blacklist);
 
   // Update the pref value for blacklist version
   prefs_->SetString(kExtensionBlacklistUpdateVersion,
                     current_extension_fetch_.version);
   prefs_->ScheduleSavePersistentPrefs();
 }
 
 void ExtensionUpdater::OnCRXFetchComplete(
-    const URLFetcher* source,
+    const content::URLFetcher* source,
     const GURL& url,
     const net::URLRequestStatus& status,
     int response_code) {
 
   base::PlatformFileError error_code = base::PLATFORM_FILE_OK;
   if (source->FileErrorOccurred(&error_code)) {
     LOG(ERROR) << "Failed to write update CRX with id "
                << current_extension_fetch_.id << ". "
                << "Error code is "<< error_code;
 
@@ skipping 313 matching lines @@
 
   std::deque<ManifestFetchData*>::const_iterator i;
   for (i = manifests_pending_.begin(); i != manifests_pending_.end(); i++) {
     if (fetch_data->full_url() == (*i)->full_url()) {
       // This url is already scheduled to be fetched.
       return;
     }
   }
 
   if (manifest_fetcher_.get() != NULL) {
-    if (manifest_fetcher_->url() != fetch_data->full_url()) {
+    if (manifest_fetcher_->GetUrl() != fetch_data->full_url()) {
       manifests_pending_.push_back(scoped_fetch_data.release());
     }
   } else {
     UMA_HISTOGRAM_COUNTS("Extensions.UpdateCheckUrlLength",
         fetch_data->full_url().possibly_invalid_spec().length());
 
     current_manifest_fetch_.swap(scoped_fetch_data);
     manifest_fetcher_.reset(
         URLFetcher::Create(kManifestFetcherId, fetch_data->full_url(),
                            URLFetcher::GET, this));
-    manifest_fetcher_->set_request_context(
-        profile_->GetRequestContext());
-    manifest_fetcher_->set_load_flags(net::LOAD_DO_NOT_SEND_COOKIES |
-                                      net::LOAD_DO_NOT_SAVE_COOKIES |
-                                      net::LOAD_DISABLE_CACHE);
+    manifest_fetcher_->SetRequestContext(profile_->GetRequestContext());
+    manifest_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
+                                    net::LOAD_DO_NOT_SAVE_COOKIES |
+                                    net::LOAD_DISABLE_CACHE);
     manifest_fetcher_->Start();
   }
 }
 
 void ExtensionUpdater::FetchUpdatedExtension(const std::string& id,
                                              const GURL& url,
                                              const std::string& hash,
                                              const std::string& version) {
   for (std::deque<ExtensionFetch>::const_iterator iter =
            extensions_pending_.begin();
        iter != extensions_pending_.end(); ++iter) {
     if (iter->id == id || iter->url == url) {
       return;  // already scheduled
     }
   }
 
   if (extension_fetcher_.get() != NULL) {
-    if (extension_fetcher_->url() != url) {
+    if (extension_fetcher_->GetUrl() != url) {
       extensions_pending_.push_back(ExtensionFetch(id, url, hash, version));
     }
   } else {
     extension_fetcher_.reset(
         URLFetcher::Create(kExtensionFetcherId, url, URLFetcher::GET, this));
-    extension_fetcher_->set_request_context(
+    extension_fetcher_->SetRequestContext(
         profile_->GetRequestContext());
-    extension_fetcher_->set_load_flags(net::LOAD_DO_NOT_SEND_COOKIES |
-                                       net::LOAD_DO_NOT_SAVE_COOKIES |
-                                       net::LOAD_DISABLE_CACHE);
+    extension_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
+                                     net::LOAD_DO_NOT_SAVE_COOKIES |
+                                     net::LOAD_DISABLE_CACHE);
     // Download CRX files to a temp file. The blacklist is small and will be
     // processed in memory, so it is fetched into a string.
     if (id != ExtensionUpdater::kBlacklistAppID) {
       extension_fetcher_->SaveResponseToTemporaryFile(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
     }
 
     extension_fetcher_->Start();
     current_extension_fetch_ = ExtensionFetch(id, url, hash, version);
   }
@@ skipping 27 matching lines @@
   std::set<std::string>::const_iterator i;
   for (i = ids.begin(); i != ids.end(); ++i)
     in_progress_ids_.insert(*i);
 }
 
 void ExtensionUpdater::RemoveFromInProgress(const std::set<std::string>& ids) {
   std::set<std::string>::const_iterator i;
   for (i = ids.begin(); i != ids.end(); ++i)
     in_progress_ids_.erase(*i);
 }