Change the DidChangeView update to take a new ViewChanged resource.

ppapi/proxy/ppb_instance_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_instance_proxy.h"
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_instance.h"
 #include "ppapi/c/ppb_messaging.h"
 #include "ppapi/c/ppb_mouse_lock.h"
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/ppb_url_util_shared.h"
+#include "ppapi/shared_impl/ppb_view_shared.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/thunk.h"
 
 // Windows headers interfere with this file.
 #ifdef PostMessage
 #undef PostMessage
 #endif
 
 using ppapi::thunk::EnterFunctionNoLock;
 using ppapi::thunk::EnterResourceNoLock;
@@ skipping 36 matching lines @@
   // Prevent the dispatcher from going away during a call to ExecuteScript.
   // This must happen OUTSIDE of ExecuteScript since the SerializedVars use
   // the dispatcher upon return of the function (converting the
   // SerializedVarReturnValue/OutParam to a SerializedVar in the destructor).
   ScopedModuleReference death_grip(dispatcher());
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_Instance_Proxy, msg)
     // Plugin -> Host messages.
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetWindowObject,
-                        OnMsgGetWindowObject)
+                        OnHostMsgGetWindowObject)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetOwnerElementObject,
-                        OnMsgGetOwnerElementObject)
+                        OnHostMsgGetOwnerElementObject)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_BindGraphics,
-                        OnMsgBindGraphics)
+                        OnHostMsgBindGraphics)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_IsFullFrame,
-                        OnMsgIsFullFrame)
+                        OnHostMsgIsFullFrame)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ExecuteScript,
-                        OnMsgExecuteScript)
+                        OnHostMsgExecuteScript)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetDefaultCharSet,
-                        OnMsgGetDefaultCharSet)
+                        OnHostMsgGetDefaultCharSet)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_Log,
-                        OnMsgLog)
+                        OnHostMsgLog)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_LogWithSource,
-                        OnMsgLogWithSource)
+                        OnHostMsgLogWithSource)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_PostMessage,
-                        OnMsgPostMessage)
+                        OnHostMsgPostMessage)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_FlashSetFullscreen,
-                        OnMsgFlashSetFullscreen)
+                        OnHostMsgFlashSetFullscreen)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_FlashGetScreenSize,
-                        OnMsgFlashGetScreenSize)
+                        OnHostMsgFlashGetScreenSize)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetFullscreen,
-                        OnMsgSetFullscreen)
+                        OnHostMsgSetFullscreen)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetScreenSize,
-                        OnMsgGetScreenSize)
+                        OnHostMsgGetScreenSize)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_RequestInputEvents,
-                        OnMsgRequestInputEvents)
+                        OnHostMsgRequestInputEvents)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ClearInputEvents,
-                        OnMsgClearInputEvents)
+                        OnHostMsgClearInputEvents)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_LockMouse,
-                        OnMsgLockMouse)
+                        OnHostMsgLockMouse)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UnlockMouse,
-                        OnMsgUnlockMouse)
+                        OnHostMsgUnlockMouse)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ResolveRelativeToDocument,
-                        OnMsgResolveRelativeToDocument)
+                        OnHostMsgResolveRelativeToDocument)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DocumentCanRequest,
-                        OnMsgDocumentCanRequest)
+                        OnHostMsgDocumentCanRequest)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DocumentCanAccessDocument,
-                        OnMsgDocumentCanAccessDocument)
+                        OnHostMsgDocumentCanAccessDocument)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetDocumentURL,
-                        OnMsgGetDocumentURL)
+                        OnHostMsgGetDocumentURL)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetPluginInstanceURL,
-                        OnMsgGetPluginInstanceURL)
+                        OnHostMsgGetPluginInstanceURL)
 
     // Host -> Plugin messages.
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBInstance_MouseLockComplete,
-                        OnMsgMouseLockComplete)
+                        OnPluginMsgMouseLockComplete)
 
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 PPB_Instance_FunctionAPI* PPB_Instance_Proxy::AsPPB_Instance_FunctionAPI() {
   return this;
 }
 
@@ skipping 11 matching lines @@
   return result;
 }
 
 PP_Bool PPB_Instance_Proxy::IsFullFrame(PP_Instance instance) {
   PP_Bool result = PP_FALSE;
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_IsFullFrame(
       API_ID_PPB_INSTANCE, instance, &result));
   return result;
 }
 
+const ViewData* PPB_Instance_Proxy::GetViewData(PP_Instance instance) {
+  InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
+      GetInstanceData(instance);
+  if (!data)
+    return NULL;
+  return &data->view;
+}
+
 PP_Var PPB_Instance_Proxy::GetWindowObject(PP_Instance instance) {
   ReceiveSerializedVarReturnValue result;
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_GetWindowObject(
       API_ID_PPB_INSTANCE, instance, &result));
   return result.Return(dispatcher());
 }
 
 PP_Var PPB_Instance_Proxy::GetOwnerElementObject(PP_Instance instance) {
   ReceiveSerializedVarReturnValue result;
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_GetOwnerElementObject(
@@ skipping 48 matching lines @@
                                                     int32_t total,
                                                     PP_Bool final_result) {
   NOTIMPLEMENTED();  // Not proxied yet.
 }
 
 void PPB_Instance_Proxy::SelectedFindResultChanged(PP_Instance instance,
                                                    int32_t index) {
   NOTIMPLEMENTED();  // Not proxied yet.
 }
 
-PP_Bool PPB_Instance_Proxy::IsFullscreen(PP_Instance instance) {
-  InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
-      GetInstanceData(instance);
-  if (!data)
-    return PP_FALSE;
-  return data->fullscreen;
-}
-
 PP_Bool PPB_Instance_Proxy::FlashIsFullscreen(PP_Instance instance) {
   InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
       GetInstanceData(instance);
   if (!data)
     return PP_FALSE;
   return data->flash_fullscreen;
 }
 
 PP_Bool PPB_Instance_Proxy::SetFullscreen(PP_Instance instance,
                                           PP_Bool fullscreen) {
@@ skipping 146 matching lines @@
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_LockMouse(
       API_ID_PPB_INSTANCE, instance));
   return PP_OK_COMPLETIONPENDING;
 }
 
 void PPB_Instance_Proxy::UnlockMouse(PP_Instance instance) {
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_UnlockMouse(
       API_ID_PPB_INSTANCE, instance));
 }
 
-void PPB_Instance_Proxy::OnMsgGetWindowObject(
+void PPB_Instance_Proxy::OnHostMsgGetWindowObject(
     PP_Instance instance,
     SerializedVarReturnValue result) {
   EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded())
     result.Return(dispatcher(), enter.functions()->GetWindowObject(instance));
 }
 
-void PPB_Instance_Proxy::OnMsgGetOwnerElementObject(
+void PPB_Instance_Proxy::OnHostMsgGetOwnerElementObject(
     PP_Instance instance,
     SerializedVarReturnValue result) {
   EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded()) {
     result.Return(dispatcher(),
                   enter.functions()->GetOwnerElementObject(instance));
   }
 }
 
-void PPB_Instance_Proxy::OnMsgBindGraphics(PP_Instance instance,
-                                           const HostResource& device,
-                                           PP_Bool* result) {
+void PPB_Instance_Proxy::OnHostMsgBindGraphics(PP_Instance instance,
+                                               const HostResource& device,
+                                               PP_Bool* result) {
   EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded()) {
     *result = enter.functions()->BindGraphics(instance,
                                               device.host_resource());
   }
 }
 
-void PPB_Instance_Proxy::OnMsgIsFullFrame(PP_Instance instance,
-                                          PP_Bool* result) {
+void PPB_Instance_Proxy::OnHostMsgIsFullFrame(PP_Instance instance,
+                                              PP_Bool* result) {
   EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded())
     *result = enter.functions()->IsFullFrame(instance);
 }
 
-void PPB_Instance_Proxy::OnMsgExecuteScript(
+void PPB_Instance_Proxy::OnHostMsgExecuteScript(
     PP_Instance instance,
     SerializedVarReceiveInput script,
     SerializedVarOutParam out_exception,
     SerializedVarReturnValue result) {
   EnterInstanceNoLock enter(instance, false);
   if (enter.failed())
     return;
 
   if (dispatcher()->IsPlugin())
     NOTREACHED();
   else
     static_cast<HostDispatcher*>(dispatcher())->set_allow_plugin_reentrancy();
 
   result.Return(dispatcher(), enter.functions()->ExecuteScript(
       instance,
       script.Get(dispatcher()),
       out_exception.OutParam(dispatcher())));
 }
 
-void PPB_Instance_Proxy::OnMsgGetDefaultCharSet(
+void PPB_Instance_Proxy::OnHostMsgGetDefaultCharSet(
     PP_Instance instance,
     SerializedVarReturnValue result) {
   EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded())
     result.Return(dispatcher(), enter.functions()->GetDefaultCharSet(instance));
 }
 
-void PPB_Instance_Proxy::OnMsgLog(PP_Instance instance,
-                                  int log_level,
-                                  SerializedVarReceiveInput value) {
+void PPB_Instance_Proxy::OnHostMsgLog(PP_Instance instance,
+                                      int log_level,
+                                      SerializedVarReceiveInput value) {
   EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded())
     enter.functions()->Log(instance, log_level, value.Get(dispatcher()));
 }
 
-void PPB_Instance_Proxy::OnMsgLogWithSource(PP_Instance instance,
-                                            int log_level,
-                                            SerializedVarReceiveInput source,
-                                            SerializedVarReceiveInput value) {
+void PPB_Instance_Proxy::OnHostMsgLogWithSource(
+    PP_Instance instance,
+    int log_level,
+    SerializedVarReceiveInput source,
+    SerializedVarReceiveInput value) {
   EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded()) {
     enter.functions()->LogWithSource(instance, log_level,
                                      source.Get(dispatcher()),
                                      value.Get(dispatcher()));
   }
 }
 
-void PPB_Instance_Proxy::OnMsgSetFullscreen(PP_Instance instance,
-                                            PP_Bool fullscreen,
-                                            PP_Bool* result) {
+void PPB_Instance_Proxy::OnHostMsgSetFullscreen(PP_Instance instance,
+                                                PP_Bool fullscreen,
+                                                PP_Bool* result) {
   EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded())
     *result = enter.functions()->SetFullscreen(instance, fullscreen);
 }
 
 
-void PPB_Instance_Proxy::OnMsgFlashSetFullscreen(PP_Instance instance,
-                                                 PP_Bool fullscreen,
-                                                 PP_Bool* result) {
+void PPB_Instance_Proxy::OnHostMsgFlashSetFullscreen(PP_Instance instance,
+                                                     PP_Bool fullscreen,
+                                                     PP_Bool* result) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
   if (enter.succeeded())
     *result = enter.functions()->FlashSetFullscreen(instance, fullscreen);
 }
 
-void PPB_Instance_Proxy::OnMsgGetScreenSize(PP_Instance instance,
-                                            PP_Bool* result,
-                                            PP_Size* size) {
+void PPB_Instance_Proxy::OnHostMsgGetScreenSize(PP_Instance instance,
+                                                PP_Bool* result,
+                                                PP_Size* size) {
   EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded())
     *result = enter.functions()->GetScreenSize(instance, size);
 }
 
-void PPB_Instance_Proxy::OnMsgFlashGetScreenSize(PP_Instance instance,
-                                                 PP_Bool* result,
-                                                 PP_Size* size) {
+void PPB_Instance_Proxy::OnHostMsgFlashGetScreenSize(PP_Instance instance,
+                                                     PP_Bool* result,
+                                                     PP_Size* size) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, false);
   if (enter.succeeded())
     *result = enter.functions()->FlashGetScreenSize(instance, size);
 }
 
-void PPB_Instance_Proxy::OnMsgRequestInputEvents(PP_Instance instance,
-                                                 bool is_filtering,
-                                                 uint32_t event_classes) {
+void PPB_Instance_Proxy::OnHostMsgRequestInputEvents(PP_Instance instance,
+                                                     bool is_filtering,
+                                                     uint32_t event_classes) {
   EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded()) {
     if (is_filtering)
       enter.functions()->RequestFilteringInputEvents(instance, event_classes);
     else
       enter.functions()->RequestInputEvents(instance, event_classes);
   }
 }
 
-void PPB_Instance_Proxy::OnMsgClearInputEvents(PP_Instance instance,
-                                               uint32_t event_classes) {
+void PPB_Instance_Proxy::OnHostMsgClearInputEvents(PP_Instance instance,
+                                                   uint32_t event_classes) {
   EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded())
     enter.functions()->ClearInputEventRequest(instance, event_classes);
 }
 
-void PPB_Instance_Proxy::OnMsgPostMessage(PP_Instance instance,
+void PPB_Instance_Proxy::OnHostMsgPostMessage(PP_Instance instance,
                                           SerializedVarReceiveInput message) {
   EnterInstanceNoLock enter(instance, false);
   if (enter.succeeded())
     enter.functions()->PostMessage(instance, message.Get(dispatcher()));
 }
 
-void PPB_Instance_Proxy::OnMsgLockMouse(PP_Instance instance) {
+void PPB_Instance_Proxy::OnHostMsgLockMouse(PP_Instance instance) {
   EnterHostFunctionForceCallback<PPB_Instance_FunctionAPI> enter(
       instance, callback_factory_,
       &PPB_Instance_Proxy::MouseLockCompleteInHost, instance);
   if (enter.succeeded())
     enter.SetResult(enter.functions()->LockMouse(instance, enter.callback()));
 }
 
-void PPB_Instance_Proxy::OnMsgUnlockMouse(PP_Instance instance) {
+void PPB_Instance_Proxy::OnHostMsgUnlockMouse(PP_Instance instance) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, true);
   if (enter.succeeded())
     enter.functions()->UnlockMouse(instance);
 }
 
-void PPB_Instance_Proxy::OnMsgResolveRelativeToDocument(
+void PPB_Instance_Proxy::OnHostMsgResolveRelativeToDocument(
     PP_Instance instance,
     SerializedVarReceiveInput relative,
     SerializedVarReturnValue result) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, true);
   if (enter.succeeded()) {
     result.Return(dispatcher(),
                   enter.functions()->ResolveRelativeToDocument(
                       instance, relative.Get(dispatcher()), NULL));
   }
 }
 
-void PPB_Instance_Proxy::OnMsgDocumentCanRequest(PP_Instance instance,
-                                                 SerializedVarReceiveInput url,
-                                                 PP_Bool* result) {
+void PPB_Instance_Proxy::OnHostMsgDocumentCanRequest(
+    PP_Instance instance,
+    SerializedVarReceiveInput url,
+    PP_Bool* result) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, true);
   if (enter.succeeded()) {
     *result = enter.functions()->DocumentCanRequest(instance,
                                                     url.Get(dispatcher()));
   }
 }
 
-void PPB_Instance_Proxy::OnMsgDocumentCanAccessDocument(PP_Instance active,
-                                                        PP_Instance target,
-                                                        PP_Bool* result) {
+void PPB_Instance_Proxy::OnHostMsgDocumentCanAccessDocument(PP_Instance active,
+                                                            PP_Instance target,
+                                                            PP_Bool* result) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(active, true);
   if (enter.succeeded())
     *result = enter.functions()->DocumentCanAccessDocument(active, target);
 }
 
-void PPB_Instance_Proxy::OnMsgGetDocumentURL(PP_Instance instance,
-                                             SerializedVarReturnValue result) {
+void PPB_Instance_Proxy::OnHostMsgGetDocumentURL(PP_Instance instance,
+                                                 SerializedVarReturnValue result) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, true);
   if (enter.succeeded()) {
     result.Return(dispatcher(),
                   enter.functions()->GetDocumentURL(instance, NULL));
   }
 }
 
-void PPB_Instance_Proxy::OnMsgGetPluginInstanceURL(
+void PPB_Instance_Proxy::OnHostMsgGetPluginInstanceURL(
     PP_Instance instance,
     SerializedVarReturnValue result) {
   EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, true);
   if (enter.succeeded()) {
     result.Return(dispatcher(),
                   enter.functions()->GetPluginInstanceURL(instance, NULL));
   }
 }
 
-void PPB_Instance_Proxy::OnMsgMouseLockComplete(PP_Instance instance,
-                                                int32_t result) {
+void PPB_Instance_Proxy::OnPluginMsgMouseLockComplete(PP_Instance instance,
+                                                      int32_t result) {
   // Save the mouse callback on the instance data.
   InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
       GetInstanceData(instance);
   if (!data)
     return;  // Instance was probably deleted.
   if (!data->mouse_lock_callback.func) {
     NOTREACHED();
     return;
   }
   PP_RunAndClearCompletionCallback(&data->mouse_lock_callback, result);
 }
 
 void PPB_Instance_Proxy::MouseLockCompleteInHost(int32_t result,
                                                  PP_Instance instance) {
   dispatcher()->Send(new PpapiMsg_PPBInstance_MouseLockComplete(
       API_ID_PPB_INSTANCE, instance, result));
 }
 
 }  // namespace proxy
 }  // namespace ppapi