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

chrome/browser/policy/device_management_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/policy/device_management_service.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/browser/policy/device_management_backend.h"
 #include "chrome/browser/policy/device_management_backend_impl.h"
 #include "content/browser/browser_thread.h"
 #include "content/public/common/content_client.h"
+#include "content/common/net/url_fetcher.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/host_resolver.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_config_service_defaults.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_response_headers.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 188 matching lines @@
   fetcher->set_load_flags(net::LOAD_DO_NOT_SEND_COOKIES |
                           net::LOAD_DO_NOT_SAVE_COOKIES |
                           net::LOAD_DISABLE_CACHE |
                           (bypass_proxy ? net::LOAD_BYPASS_PROXY : 0));
   fetcher->set_request_context(request_context_getter_.get());
   job->ConfigureRequest(fetcher);
   pending_jobs_[fetcher] = job;
   fetcher->Start();
 }
 
-void DeviceManagementService::OnURLFetchComplete(
-    const URLFetcher* source,
-    const GURL& url,
-    const net::URLRequestStatus& status,
-    int response_code,
-    const net::ResponseCookies& cookies,
-    const std::string& data) {
+void DeviceManagementService::OnURLFetchComplete(const URLFetcher* source) {
   JobFetcherMap::iterator entry(pending_jobs_.find(source));
   if (entry != pending_jobs_.end()) {
     DeviceManagementJob* job = entry->second;
     pending_jobs_.erase(entry);
 
     // Retry the job if it failed due to a broken proxy, by bypassing the
     // proxy on the next try. Don't retry if this URLFetcher already bypassed
     // the proxy.
     bool retry = false;
     if ((source->load_flags() & net::LOAD_BYPASS_PROXY) == 0) {
-      if (!status.is_success() && IsProxyError(status)) {
+      if (!source->status().is_success() && IsProxyError(source->status())) {
         LOG(WARNING) << "Proxy failed while contacting dmserver.";
         retry = true;
-      } else if (status.is_success() &&
+      } else if (source->status().is_success() &&
                  source->was_fetched_via_proxy() &&
                  !IsProtobufMimeType(source)) {
         // The proxy server can be misconfigured but pointing to an existing
         // server that replies to requests. Try to recover if a successful
         // request that went through a proxy returns an unexpected mime type.
         LOG(WARNING) << "Got bad mime-type in response from dmserver that was "
                      << "fetched via a proxy.";
         retry = true;
       }
     }
 
     if (retry) {
       LOG(WARNING) << "Retrying dmserver request without using a proxy.";
       StartJob(job, true);
     } else {
-      job->HandleResponse(status, response_code, cookies, data);
+      std::string data;
+      source->GetResponseAsString(&data);
+      job->HandleResponse(source->status(), source->response_code(),
+                          source->cookies(), data);
     }
   } else {
     NOTREACHED() << "Callback from foreign URL fetcher";
   }
   delete source;
 }
 
 }  // namespace policy