Add new MouseCursor interface for setting the mouse cursor.

ppapi/proxy/ppb_instance_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_instance_proxy.h"
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_time.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_audio_config.h"
@@ skipping 106 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ResolveRelativeToDocument,
                         OnHostMsgResolveRelativeToDocument)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DocumentCanRequest,
                         OnHostMsgDocumentCanRequest)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_DocumentCanAccessDocument,
                         OnHostMsgDocumentCanAccessDocument)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetDocumentURL,
                         OnHostMsgGetDocumentURL)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_GetPluginInstanceURL,
                         OnHostMsgGetPluginInstanceURL)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetCursor,
+                        OnHostMsgSetCursor)
 
     // Host -> Plugin messages.
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBInstance_MouseLockComplete,
                         OnPluginMsgMouseLockComplete)
 
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
@@ skipping 259 matching lines @@
       components);
 }
 
 void PPB_Instance_Proxy::PostMessage(PP_Instance instance,
                                      PP_Var message) {
   dispatcher()->Send(new PpapiHostMsg_PPBInstance_PostMessage(
       API_ID_PPB_INSTANCE,
       instance, SerializedVarSendInput(dispatcher(), message)));
 }
 
+PP_Bool PPB_Instance_Proxy::SetCursor(PP_Instance instance,
+                                      PP_MouseCursor_Type type,
+                                      PP_Resource image,
+                                      const PP_Point* hot_spot) {
+  // Some of these parameters are important for security. This check is in the
+  // plugin process just for the convenience of the caller (since we don't
+  // bother returning errors from the other process with a sync message). The
+  // parameters will be validated again in the renderer.
+  if (!ValidateSetCursorParams(type, image, hot_spot))
+    return PP_FALSE;
+
+  HostResource image_host_resource;
+  if (image) {
+    Resource* cursor_image =
+        PpapiGlobals::Get()->GetResourceTracker()->GetResource(image);
+    if (!cursor_image || cursor_image->pp_instance() != instance)
+      return PP_FALSE;
+    image_host_resource = cursor_image->host_resource();
+  }
+
+  dispatcher()->Send(new PpapiHostMsg_PPBInstance_SetCursor(
+      API_ID_PPB_INSTANCE, instance, static_cast<int32_t>(type),
+      image_host_resource, hot_spot ? *hot_spot : PP_MakePoint(0, 0)));
+  return PP_TRUE;
+}
+
 int32_t PPB_Instance_Proxy::LockMouse(PP_Instance instance,
                                       PP_CompletionCallback callback) {
   if (!callback.func)
     return PP_ERROR_BADARGUMENT;
 
   // Save the mouse callback on the instance data.
   InstanceData* data = static_cast<PluginDispatcher*>(dispatcher())->
       GetInstanceData(instance);
   if (!data)
     return PP_ERROR_BADARGUMENT;
@@ skipping 214 matching lines @@
 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::OnHostMsgSetCursor(
+    PP_Instance instance,
+    int32_t type,
+    const ppapi::HostResource& custom_image,
+    const PP_Point& hot_spot) {
+  EnterInstanceNoLock enter(instance, true);
+  if (enter.succeeded()) {
+    enter.functions()->SetCursor(
+        instance, static_cast<PP_MouseCursor_Type>(type),
+        custom_image.host_resource(), &hot_spot);
+  }
+}
+
 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