Move ResourceResponse struct into the Content API, since it's used in Chrome. While at it, I also...

content/browser/renderer_host/resource_dispatcher_host.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <set>
 #include <vector>
@@ skipping 65 matching lines @@
 #include "net/url_request/url_request_job_factory.h"
 #include "webkit/appcache/appcache_interceptor.h"
 #include "webkit/appcache/appcache_interfaces.h"
 #include "webkit/blob/blob_storage_controller.h"
 #include "webkit/blob/deletable_file_reference.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 using content::BrowserThread;
+using content::ResourceResponse;
 using webkit_blob::DeletableFileReference;
 
 // ----------------------------------------------------------------------------
 
 // A ShutdownTask proxies a shutdown task from the UI thread to the IO thread.
 // It should be constructed on the UI thread and run in the IO thread.
 class ResourceDispatcherHost::ShutdownTask : public Task {
  public:
   explicit ShutdownTask(ResourceDispatcherHost* resource_dispatcher_host)
       : rdh_(resource_dispatcher_host) {
@@ skipping 38 matching lines @@
 };
 
 // Aborts a request before an URLRequest has actually been created.
 void AbortRequestBeforeItStarts(ResourceMessageFilter* filter,
                                 IPC::Message* sync_result,
                                 int route_id,
                                 int request_id) {
   net::URLRequestStatus status(net::URLRequestStatus::FAILED,
                                net::ERR_ABORTED);
   if (sync_result) {
-    SyncLoadResult result;
+    content::SyncLoadResult result;
     result.status = status;
     ResourceHostMsg_SyncLoad::WriteReplyParams(sync_result, result);
     filter->Send(sync_result);
   } else {
     // Tell the renderer that this request was disallowed.
     filter->Send(new ResourceMsg_RequestComplete(
         route_id,
         request_id,
         status,
         std::string(),   // No security info needed, connection was not
@@ skipping 40 matching lines @@
         return false;
       }
     }
   }
 
   return true;
 }
 
 void PopulateResourceResponse(net::URLRequest* request,
                               ResourceResponse* response) {
-  response->response_head.status = request->status();
-  response->response_head.request_time = request->request_time();
-  response->response_head.response_time = request->response_time();
-  response->response_head.headers = request->response_headers();
-  request->GetCharset(&response->response_head.charset);
-  response->response_head.content_length = request->GetExpectedContentSize();
-  request->GetMimeType(&response->response_head.mime_type);
-  response->response_head.was_fetched_via_spdy =
-      request->was_fetched_via_spdy();
-  response->response_head.was_npn_negotiated = request->was_npn_negotiated();
-  response->response_head.was_fetched_via_proxy =
-      request->was_fetched_via_proxy();
-  response->response_head.socket_address = request->GetSocketAddress();
+  response->status = request->status();
+  response->request_time = request->request_time();
+  response->response_time = request->response_time();
+  response->headers = request->response_headers();
+  request->GetCharset(&response->charset);
+  response->content_length = request->GetExpectedContentSize();
+  request->GetMimeType(&response->mime_type);
+  response->was_fetched_via_spdy = request->was_fetched_via_spdy();
+  response->was_npn_negotiated = request->was_npn_negotiated();
+  response->was_fetched_via_proxy = request->was_fetched_via_proxy();
+  response->socket_address = request->GetSocketAddress();
   appcache::AppCacheInterceptor::GetExtraResponseInfo(
       request,
-      &response->response_head.appcache_id,
-      &response->response_head.appcache_manifest_url);
+      &response->appcache_id,
+      &response->appcache_manifest_url);
 }
 
 void RemoveDownloadFileFromChildSecurityPolicy(int child_id,
                                                const FilePath& path) {
   ChildProcessSecurityPolicy::GetInstance()->RevokeAllPermissionsForFile(
       child_id, path);
 }
 
 #if defined(OS_WIN)
 #pragma warning(disable: 4748)
@@ skipping 1164 matching lines @@
 bool ResourceDispatcherHost::CompleteResponseStarted(net::URLRequest* request) {
   ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   PopulateResourceResponse(request, response);
 
   if (request->ssl_info().cert) {
     int cert_id =
         CertStore::GetInstance()->StoreCert(request->ssl_info().cert,
                                             info->child_id());
-    response->response_head.security_info =
+    response->security_info =
         SSLManager::SerializeSecurityInfo(
             cert_id, request->ssl_info().cert_status,
             request->ssl_info().security_bits,
             request->ssl_info().connection_status);
   } else {
     // We should not have any SSL state.
     DCHECK(!request->ssl_info().cert_status &&
            request->ssl_info().security_bits == -1 &&
            !request->ssl_info().connection_status);
   }
@@ skipping 752 matching lines @@
   return HTTP_AUTH_RESOURCE_BLOCKED_CROSS;
 }
 
 bool ResourceDispatcherHost::allow_cross_origin_auth_prompt() {
   return allow_cross_origin_auth_prompt_;
 }
 
 void ResourceDispatcherHost::set_allow_cross_origin_auth_prompt(bool value) {
   allow_cross_origin_auth_prompt_ = value;
 }