Convert URLFetcher::Delegates to use an interface in content/public/common. Also remove the old U...

chrome/browser/intranet_redirect_detector.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/intranet_redirect_detector.h"
 
 #include "base/command_line.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
+#include "content/common/net/url_fetcher.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/registry_controlled_domain.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 const size_t IntranetRedirectDetector::kNumCharsInHostnames = 10;
 
 IntranetRedirectDetector::IntranetRedirectDetector()
     : redirect_origin_(g_browser_process->local_state()->GetString(
@@ skipping 57 matching lines @@
     URLFetcher* fetcher = new URLFetcher(random_url, URLFetcher::HEAD, this);
     // We don't want these fetches to affect existing state in the profile.
     fetcher->set_load_flags(net::LOAD_DISABLE_CACHE |
                             net::LOAD_DO_NOT_SAVE_COOKIES);
     fetcher->set_request_context(g_browser_process->system_request_context());
     fetcher->Start();
     fetchers_.insert(fetcher);
   }
 }
 
-void IntranetRedirectDetector::OnURLFetchComplete(
-    const URLFetcher* source,
-    const GURL& url,
-    const net::URLRequestStatus& status,
-    int response_code,
-    const net::ResponseCookies& cookies,
-    const std::string& data) {
+void IntranetRedirectDetector::OnURLFetchComplete(const URLFetcher* source) {
   // Delete the fetcher on this function's exit.
   Fetchers::iterator fetcher = fetchers_.find(const_cast<URLFetcher*>(source));
   DCHECK(fetcher != fetchers_.end());
   scoped_ptr<URLFetcher> clean_up_fetcher(*fetcher);
   fetchers_.erase(fetcher);
 
   // If any two fetches result in the same domain/host, we set the redirect
   // origin to that; otherwise we set it to nothing.
-  if (!status.is_success() || (response_code != 200)) {
+  if (!source->status().is_success() || (source->response_code() != 200)) {
     if ((resulting_origins_.empty()) ||
         ((resulting_origins_.size() == 1) &&
          resulting_origins_.front().is_valid())) {
       resulting_origins_.push_back(GURL());
       return;
     }
     redirect_origin_ = GURL();
   } else {
-    DCHECK(url.is_valid());
-    GURL origin(url.GetOrigin());
+    DCHECK(source->url().is_valid());
+    GURL origin(source->url().GetOrigin());
     if (resulting_origins_.empty()) {
       resulting_origins_.push_back(origin);
       return;
     }
     if (net::RegistryControlledDomainService::SameDomainOrHost(
         resulting_origins_.front(), origin)) {
       redirect_origin_ = origin;
       if (!fetchers_.empty()) {
         // Cancel remaining fetch, we don't need it.
         DCHECK(fetchers_.size() == 1);
@@ skipping 45 matching lines @@
   // the same thread.  So just use the heuristic that any all-lowercase a-z
   // hostname with the right number of characters is likely from the detector
   // (and thus should be blocked).
   return ((host.length() == IntranetRedirectDetector::kNumCharsInHostnames) &&
       (host.find_first_not_of("abcdefghijklmnopqrstuvwxyz") ==
           std::string::npos)) ?
       net::ERR_NAME_NOT_RESOLVED :
       ResolveUsingPrevious(host, address_family, host_resolver_flags, addrlist,
                            os_error);
 }