Implement proxy for FlashMenu and Run/QuitMessageLoop

ppapi/proxy/ppb_flash_proxy.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 "ppapi/proxy/ppb_flash_proxy.h"
 
 #include "base/logging.h"
+#include "base/message_loop.h"
 #include "build/build_config.h"
 #include "ppapi/c/dev/pp_file_info_dev.h"
 #include "ppapi/c/dev/ppb_font_dev.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/private/ppb_flash.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource.h"
 #include "ppapi/proxy/ppapi_messages.h"
@@ skipping 210 matching lines @@
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return PP_FALSE;
 
   PP_Bool result = PP_FALSE;
   dispatcher->Send(new PpapiHostMsg_PPBFlash_NavigateToURL(
       INTERFACE_ID_PPB_FLASH, instance, url, target, &result));
   return result;
 }
 
+void RunMessageLoop(PP_Instance instance) {
+  PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
+  if (!dispatcher)
+    return;
+  IPC::SyncMessage* msg = new PpapiHostMsg_PPBFlash_RunMessageLoop(
+        INTERFACE_ID_PPB_FLASH, instance);
+  msg->EnableMessagePumping();
+  dispatcher->Send(msg);
+}
+
+void QuitMessageLoop(PP_Instance instance) {
+  PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
+  if (!dispatcher)
+    return;
+  dispatcher->Send(new PpapiHostMsg_PPBFlash_QuitMessageLoop(
+        INTERFACE_ID_PPB_FLASH, instance));
+}
+
 const PPB_Flash flash_interface = {
   &SetInstanceAlwaysOnTop,
   &DrawGlyphs,
   &GetProxyForURL,
   &OpenModuleLocalFile,
   &RenameModuleLocalFile,
   &DeleteModuleLocalFileOrDir,
   &CreateModuleLocalDir,
   &QueryModuleLocalFile,
   &GetModuleLocalDirContents,
   &FreeModuleLocalDirContents,
   &NavigateToURL,
+  &RunMessageLoop,
+  &QuitMessageLoop,
 };
 
 InterfaceProxy* CreateFlashProxy(Dispatcher* dispatcher,
                                  const void* target_interface) {
   return new PPB_Flash_Proxy(dispatcher, target_interface);
 }
 
 }  // namespace
 
 PPB_Flash_Proxy::PPB_Flash_Proxy(Dispatcher* dispatcher,
@@ skipping 31 matching lines @@
                         OnMsgRenameModuleLocalFile)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_DeleteModuleLocalFileOrDir,
                         OnMsgDeleteModuleLocalFileOrDir)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_CreateModuleLocalDir,
                         OnMsgCreateModuleLocalDir)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_QueryModuleLocalFile,
                         OnMsgQueryModuleLocalFile)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_GetModuleLocalDirContents,
                         OnMsgGetModuleLocalDirContents)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_NavigateToURL, OnMsgNavigateToURL)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_RunMessageLoop,
+                        OnMsgRunMessageLoop)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_QuitMessageLoop,
+                        OnMsgQuitMessageLoop)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   // TODO(brettw) handle bad messages!
   return handled;
 }
 
 void PPB_Flash_Proxy::OnMsgSetInstanceAlwaysOnTop(
     PP_Instance instance,
     PP_Bool on_top) {
   ppb_flash_target()->SetInstanceAlwaysOnTop(instance, on_top);
@@ skipping 96 matching lines @@
 }
 
 void PPB_Flash_Proxy::OnMsgNavigateToURL(PP_Instance instance,
                                          const std::string& url,
                                          const std::string& target,
                                          PP_Bool* result) {
   *result = ppb_flash_target()->NavigateToURL(instance, url.c_str(),
                                               target.c_str());
 }
 
+void PPB_Flash_Proxy::OnMsgRunMessageLoop(PP_Instance instance) {
+  ppb_flash_target()->RunMessageLoop(instance);
+}
+
+void PPB_Flash_Proxy::OnMsgQuitMessageLoop(PP_Instance instance) {
+  ppb_flash_target()->QuitMessageLoop(instance);
+}
+
 }  // namespace proxy
 }  // namespace pp