Convert url request info to new proxy API.

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/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>
 #endif
 
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_URLLoader_API;
 using ppapi::thunk::ResourceCreationAPI;
@@ skipping 45 matching lines @@
  public:
   URLLoader(const HostResource& resource);
   virtual ~URLLoader();
 
   // Resource overrides.
   virtual PPB_URLLoader_API* AsPPB_URLLoader_API() OVERRIDE;
 
   // PPB_URLLoader_API implementation.
   virtual int32_t Open(PP_Resource request_id,
                        scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t Open(const URLRequestInfoData& data,
+                       scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual int32_t FollowRedirect(
       scoped_refptr<TrackedCallback> callback) OVERRIDE;
   virtual PP_Bool GetUploadProgress(int64_t* bytes_sent,
                                     int64_t* total_bytes_to_be_sent) OVERRIDE;
   virtual PP_Bool GetDownloadProgress(
       int64_t* bytes_received,
       int64_t* total_bytes_to_be_received) OVERRIDE;
   virtual PP_Resource GetResponseInfo() OVERRIDE;
   virtual int32_t ReadResponseBody(
       void* buffer,
@@ skipping 77 matching lines @@
 int32_t URLLoader::Open(PP_Resource request_id,
                         scoped_refptr<TrackedCallback> callback) {
   EnterResourceNoLock<thunk::PPB_URLRequestInfo_API> enter(request_id, true);
   if (enter.failed()) {
     Log(PP_LOGLEVEL_ERROR, "PPB_URLLoader.Open: The URL you're requesting is "
         " on a different security origin than your plugin. To request "
         " cross-origin resources, see "
         " PP_URLREQUESTPROPERTY_ALLOWCROSSORIGINREQUESTS.");
     return PP_ERROR_BADRESOURCE;
   }
+  return Open(enter.object()->GetData(), callback);
+}
 
+int32_t URLLoader::Open(const URLRequestInfoData& data,
+                        scoped_refptr<TrackedCallback> callback) {
   if (TrackedCallback::IsPending(current_callback_))
     return PP_ERROR_INPROGRESS;
 
   current_callback_ = callback;
 
   GetDispatcher()->Send(new PpapiHostMsg_PPBURLLoader_Open(
-      API_ID_PPB_URL_LOADER, host_resource(), enter.object()->GetData()));
+      API_ID_PPB_URL_LOADER, host_resource(), data));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t URLLoader::FollowRedirect(scoped_refptr<TrackedCallback> callback) {
   if (TrackedCallback::IsPending(current_callback_))
     return PP_ERROR_INPROGRESS;
 
   current_callback_ = callback;
 
   GetDispatcher()->Send(new PpapiHostMsg_PPBURLLoader_FollowRedirect(
@@ skipping 235 matching lines @@
                                       HostResource* result) {
   thunk::EnterResourceCreation enter(instance);
   if (enter.succeeded()) {
     result->SetHostResource(instance,
                             enter.functions()->CreateURLLoader(instance));
     PrepareURLLoaderForSendingToPlugin(result->host_resource());
   }
 }
 
 void PPB_URLLoader_Proxy::OnMsgOpen(const HostResource& loader,
-                                    const PPB_URLRequestInfo_Data& data) {
+                                    const URLRequestInfoData& data) {
   EnterHostFromHostResourceForceCallback<PPB_URLLoader_API> enter(
       loader, callback_factory_, &PPB_URLLoader_Proxy::OnCallback, loader);
-  thunk::EnterResourceCreation enter_creation(loader.instance());
-  if (enter.failed() || enter_creation.failed())
-    return;
-
-  ScopedPPResource request_resource(
-      ScopedPPResource::PassRef(),
-      enter_creation.functions()->CreateURLRequestInfo(loader.instance(),
-                                                       data));
-  enter.SetResult(enter.object()->Open(request_resource, enter.callback()));
+  enter.SetResult(enter.object()->Open(data, enter.callback()));
   // TODO(brettw) bug 73236 register for the status callbacks.
 }
 
 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()));
 }
@@ skipping 111 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));
 }
 
 }  // namespace proxy
 }  // namespace ppapi