Refactor the URLResponseInfo to use new design

ppapi/proxy/ppb_url_loader_proxy.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 "ppapi/proxy/ppb_url_loader_proxy.h"
 
 #include <algorithm>
 #include <deque>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/ppb_url_loader.h"
 #include "ppapi/c/private/ppb_proxy_private.h"
 #include "ppapi/c/trusted/ppb_url_loader_trusted.h"
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
-#include "ppapi/proxy/ppb_url_response_info_proxy.h"
+#include "ppapi/proxy/ppb_file_ref_proxy.h"
 #include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/shared_impl/tracked_callback.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_url_loader_api.h"
 #include "ppapi/thunk/ppb_url_request_info_api.h"
 #include "ppapi/thunk/resource_creation_api.h"
 #include "ppapi/thunk/thunk.h"
 
 #if defined(OS_LINUX)
 #include <sys/shm.h>
@@ skipping 71 matching lines @@
   virtual int32_t ReadResponseBody(
       void* buffer,
       int32_t bytes_to_read,
       scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t FinishStreamingToFile(
       scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual void Close() OVERRIDE;
   virtual void GrantUniversalAccess() OVERRIDE;
   virtual void SetStatusCallback(
       PP_URLLoaderTrusted_StatusCallback cb) OVERRIDE;
+  virtual bool GetResponseInfoData(URLResponseInfoData* data) OVERRIDE;
 
   // Called when the browser has new up/download progress to report.
   void UpdateProgress(const PPBURLLoader_UpdateProgress_Params& params);
 
   // Called when the browser responds to our ReadResponseBody request.
   void ReadResponseBodyAck(int32_t result, const char* data);
 
   // Called when any callback other than the read callback has been executed.
   void CallbackComplete(int32_t result);
 
@@ skipping 115 matching lines @@
     *total_bytes_to_be_received = 0;
     return PP_FALSE;
   }
   *bytes_received = bytes_received_;
   *total_bytes_to_be_received = total_bytes_to_be_received_;
   return PP_TRUE;
 }
 
 PP_Resource URLLoader::GetResponseInfo() {
   if (!response_info_) {
-    HostResource response_id;
+    bool success = false;
+    URLResponseInfoData data;
     GetDispatcher()->Send(new PpapiHostMsg_PPBURLLoader_GetResponseInfo(
-        API_ID_PPB_URL_LOADER, host_resource(), &response_id));
-    if (response_id.is_null())
+        API_ID_PPB_URL_LOADER, host_resource(), &success, &data));
+    if (!success)
       return 0;
 
-    response_info_ = PPB_URLResponseInfo_Proxy::CreateResponseForResource(
-        response_id);
+    // Create a proxy resource for the the file ref host resource if needed.
+    PP_Resource body_as_file_ref = 0;
+    if (!data.body_as_file_ref.resource.is_null()) {
+      body_as_file_ref =
+          PPB_FileRef_Proxy::DeserializeFileRef(data.body_as_file_ref);
+    }
+
+    // Assumes ownership of body_as_file_ref.
+    thunk::EnterResourceCreationNoLock enter(pp_instance());
+    response_info_ = enter.functions()->CreateURLResponseInfo(
+        pp_instance(), data, body_as_file_ref);
   }
 
   // The caller expects to get a ref, and we want to keep holding ours.
   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(response_info_);
   return response_info_;
 }
 
 int32_t URLLoader::ReadResponseBody(void* buffer,
                                     int32_t bytes_to_read,
                                     scoped_refptr<TrackedCallback> callback) {
@@ skipping 42 matching lines @@
       new PpapiHostMsg_PPBURLLoader_GrantUniversalAccess(
           API_ID_PPB_URL_LOADER, host_resource()));
 }
 
 void URLLoader::SetStatusCallback(
     PP_URLLoaderTrusted_StatusCallback cb) {
   // Not implemented in the proxied version, this is for implementing the
   // proxy itself in the host.
 }
 
+bool URLLoader::GetResponseInfoData(URLResponseInfoData* data) {
+  // Not implemented in the proxied version, this is for implementing the
+  // proxy itself in the host.
+  return false;
+}
+
 void URLLoader::UpdateProgress(
     const PPBURLLoader_UpdateProgress_Params& params) {
   bytes_sent_ = params.bytes_sent;
   total_bytes_to_be_sent_ = params.total_bytes_to_be_sent;
   bytes_received_ = params.bytes_received;
   total_bytes_to_be_received_ = params.total_bytes_to_be_received;
 }
 
 void URLLoader::ReadResponseBodyAck(int32 result, const char* data) {
   if (!TrackedCallback::IsPending(current_callback_) || !current_read_buffer_) {
@@ skipping 145 matching lines @@
 
 void PPB_URLLoader_Proxy::OnMsgFollowRedirect(
     const HostResource& loader) {
   EnterHostFromHostResourceForceCallback<PPB_URLLoader_API> enter(
       loader, callback_factory_, &PPB_URLLoader_Proxy::OnCallback, loader);
   if (enter.succeeded())
     enter.SetResult(enter.object()->FollowRedirect(enter.callback()));
 }
 
 void PPB_URLLoader_Proxy::OnMsgGetResponseInfo(const HostResource& loader,
-                                               HostResource* result) {
+                                               bool* success,
+                                               URLResponseInfoData* result) {
   EnterHostFromHostResource<PPB_URLLoader_API> enter(loader);
-  if (enter.succeeded()) {
-    result->SetHostResource(loader.instance(),
-                            enter.object()->GetResponseInfo());
-  }
+  if (enter.succeeded())
+    *success = enter.object()->GetResponseInfoData(result);
+  else
+    *success = false;
 }
 
 void PPB_URLLoader_Proxy::OnMsgReadResponseBody(
     const HostResource& loader,
     int32_t bytes_to_read) {
   // The plugin could be sending us malicious messages, don't accept negative
   // sizes.
   if (bytes_to_read < 0) {
     // TODO(brettw) kill plugin.
     bytes_to_read = 0;
@@ skipping 119 matching lines @@
 
 void PPB_URLLoader_Proxy::OnCallback(int32_t result,
                                      const HostResource& resource) {
   dispatcher()->Send(new PpapiMsg_PPBURLLoader_CallbackComplete(
       API_ID_PPB_URL_LOADER, resource, result));
 }
 #endif  // !defined(OS_NACL)
 
 }  // namespace proxy
 }  // namespace ppapi