Convert url request info to new proxy API.

ppapi/proxy/ppb_flash_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_flash_proxy.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 184 matching lines @@
 }
 
 int32_t PPB_Flash_Proxy::Navigate(PP_Instance instance,
                                   PP_Resource request_info,
                                   const char* target,
                                   PP_Bool from_user_action) {
   thunk::EnterResourceNoLock<thunk::PPB_URLRequestInfo_API> enter(
       request_info, true);
   if (enter.failed())
     return PP_ERROR_BADRESOURCE;
+  return Navigate(instance, enter.object()->GetData(), target,
+                  from_user_action);
+}
 
+int32_t PPB_Flash_Proxy::Navigate(PP_Instance instance,
+                                  const URLRequestInfoData& data,
+                                  const char* target,
+                                  PP_Bool from_user_action) {
   int32_t result = PP_ERROR_FAILED;
   dispatcher()->Send(new PpapiHostMsg_PPBFlash_Navigate(
-      API_ID_PPB_FLASH,
-      instance, enter.object()->GetData(), target, from_user_action,
-      &result));
+      API_ID_PPB_FLASH, instance, data, target, from_user_action, &result));
   return result;
 }
 
 void PPB_Flash_Proxy::RunMessageLoop(PP_Instance instance) {
   IPC::SyncMessage* msg = new PpapiHostMsg_PPBFlash_RunMessageLoop(
       API_ID_PPB_FLASH, instance);
   msg->EnableMessagePumping();
   dispatcher()->Send(msg);
 }
 
@@ skipping 430 matching lines @@
   if (enter.succeeded()) {
     result.Return(dispatcher(),
                   enter.functions()->GetFlashAPI()->GetProxyForURL(
                       instance, url.c_str()));
   } else {
     result.Return(dispatcher(), PP_MakeUndefined());
   }
 }
 
 void PPB_Flash_Proxy::OnHostMsgNavigate(PP_Instance instance,
-                                        const PPB_URLRequestInfo_Data& data,
+                                        const URLRequestInfoData& data,
                                         const std::string& target,
                                         PP_Bool from_user_action,
                                         int32_t* result) {
   EnterInstanceNoLock enter_instance(instance);
   if (enter_instance.failed()) {
     *result = PP_ERROR_BADARGUMENT;
     return;
   }
   DCHECK(!dispatcher()->IsPlugin());
 
   // Validate the PP_Instance since we'll be constructing resources on its
   // behalf.
   HostDispatcher* host_dispatcher = static_cast<HostDispatcher*>(dispatcher());
   if (HostDispatcher::GetForInstance(instance) != host_dispatcher) {
     NOTREACHED();
     *result = PP_ERROR_BADARGUMENT;
     return;
   }
 
   // We need to allow re-entrancy here, because this may call into Javascript
   // (e.g. with a "javascript:" URL), or do things like navigate away from the
   // page, either one of which will need to re-enter into the plugin.
   // It is safe, because it is essentially equivalent to NPN_GetURL, where Flash
   // would expect re-entrancy. When running in-process, it does re-enter here.
   host_dispatcher->set_allow_plugin_reentrancy();
-
-  // Make a temporary request resource.
-  thunk::EnterResourceCreation enter(instance);
-  if (enter.failed()) {
-    *result = PP_ERROR_FAILED;
-    return;
-  }
-  ScopedPPResource request_resource(
-      ScopedPPResource::PassRef(),
-      enter.functions()->CreateURLRequestInfo(instance, data));
-
   *result = enter_instance.functions()->GetFlashAPI()->Navigate(
-      instance, request_resource, target.c_str(), from_user_action);
+      instance, data, target.c_str(), from_user_action);
 }
 
 void PPB_Flash_Proxy::OnHostMsgRunMessageLoop(PP_Instance instance) {
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
     enter.functions()->GetFlashAPI()->RunMessageLoop(instance);
 }
 
 void PPB_Flash_Proxy::OnHostMsgQuitMessageLoop(PP_Instance instance) {
   EnterInstanceNoLock enter(instance);
@@ skipping 171 matching lines @@
   // It's rarely used enough that we just request this interface when needed.
   const PPB_Flash_Print_1_0* print_interface =
       static_cast<const PPB_Flash_Print_1_0*>(
           dispatcher()->local_get_interface()(PPB_FLASH_PRINT_INTERFACE_1_0));
   if (print_interface)
     print_interface->InvokePrinting(instance);
 }
 
 }  // namespace proxy
 }  // namespace ppapi