Move text input API to Instance.

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 12 matching lines @@
 #include "ppapi/shared_impl/ppb_view_shared.h"
 #include "ppapi/shared_impl/var.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::EnterInstanceNoLock;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Instance_FunctionAPI;
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
-typedef EnterFunctionNoLock<PPB_Instance_FunctionAPI> EnterInstanceNoLock;
-
 InterfaceProxy* CreateInstanceProxy(Dispatcher* dispatcher) {
   return new PPB_Instance_Proxy(dispatcher);
 }
 
+void RequestSurroundingText(PP_Instance instance) {
+  PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
+  if (!dispatcher)
+    return;  // Instance has gone away while message was pending.
+
+  // Just fake out a RequestSurroundingText message to the proxy for the PPP
+  // interface.
+  InterfaceProxy* proxy = dispatcher->GetInterfaceProxy(API_ID_PPB_TEXT_INPUT);
+  if (!proxy)
+    return;
+  proxy->OnMessageReceived(PpapiMsg_PPPTextInput_RequestSurroundingText(
+      API_ID_PPP_TEXT_INPUT, instance,
+      PPB_Instance_Shared::kExtraCharsForTextInput));
+}
+
 }  // namespace
 
 PPB_Instance_Proxy::PPB_Instance_Proxy(Dispatcher* dispatcher)
     : InterfaceProxy(dispatcher),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 PPB_Instance_Proxy::~PPB_Instance_Proxy() {
 }
 
@@ skipping 48 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_ClearInputEvents,
                         OnHostMsgClearInputEvents)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPInputEvent_HandleInputEvent_ACK,
                         OnMsgHandleInputEventAck)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_LockMouse,
                         OnHostMsgLockMouse)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UnlockMouse,
                         OnHostMsgUnlockMouse)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetCursor,
                         OnHostMsgSetCursor)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_SetTextInputType,
+                        OnHostMsgSetTextInputType)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UpdateCaretPosition,
+                        OnHostMsgUpdateCaretPosition)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_CancelCompositionText,
+                        OnHostMsgCancelCompositionText)
+    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBInstance_UpdateSurroundingText,
+                        OnHostMsgUpdateSurroundingText)
 #if !defined(OS_NACL)
     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,
@@ skipping 304 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::SetTextInputType(PP_Instance instance,
+                                          PP_TextInput_Type type) {
+  dispatcher()->Send(new PpapiHostMsg_PPBInstance_SetTextInputType(
+      API_ID_PPB_INSTANCE, instance, type));
+}
+
+void PPB_Instance_Proxy::UpdateCaretPosition(PP_Instance instance,
+                                             const PP_Rect& caret,
+                                             const PP_Rect& bounding_box) {
+  dispatcher()->Send(new PpapiHostMsg_PPBInstance_UpdateCaretPosition(
+      API_ID_PPB_INSTANCE, instance, caret, bounding_box));
+}
+
+void PPB_Instance_Proxy::CancelCompositionText(PP_Instance instance) {
+  dispatcher()->Send(new PpapiHostMsg_PPBInstance_CancelCompositionText(
+      API_ID_PPB_INSTANCE, instance));
+}
+
+void PPB_Instance_Proxy::SelectionChanged(PP_Instance instance) {
+  // The "right" way to do this is to send the message to the host. However,
+  // all it will do it call RequestSurroundingText with a hardcoded number of
+  // characters in response, which is an entire IPC round-trip.
+  //
+  // We can avoid this round-trip by just implementing the
+  // RequestSurroundingText logic in the plugin process. If the logic in the
+  // host becomes more complex (like a more adaptive number of characters),
+  // we'll need to reevanuate whether we want to do the round trip instead.
+  //
+  // Be careful to post a task to avoid reentering the plugin.
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&RequestSurroundingText, instance));
+}
+
+void PPB_Instance_Proxy::UpdateSurroundingText(PP_Instance instance,
+                                               const char* text,
+                                               uint32_t caret,
+                                               uint32_t anchor) {
+  dispatcher()->Send(new PpapiHostMsg_PPBInstance_UpdateSurroundingText(
+      API_ID_PPB_INSTANCE, instance, text, caret, anchor));
+}
+
 void PPB_Instance_Proxy::OnHostMsgGetWindowObject(
     PP_Instance instance,
     SerializedVarReturnValue result) {
-  EnterInstanceNoLock enter(instance, false);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
     result.Return(dispatcher(), enter.functions()->GetWindowObject(instance));
 }
 
 void PPB_Instance_Proxy::OnHostMsgGetOwnerElementObject(
     PP_Instance instance,
     SerializedVarReturnValue result) {
-  EnterInstanceNoLock enter(instance, false);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     result.Return(dispatcher(),
                   enter.functions()->GetOwnerElementObject(instance));
   }
 }
 
 void PPB_Instance_Proxy::OnHostMsgBindGraphics(PP_Instance instance,
                                                const HostResource& device,
                                                PP_Bool* result) {
-  EnterInstanceNoLock enter(instance, false);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     *result = enter.functions()->BindGraphics(instance,
                                               device.host_resource());
   }
 }
 
 void PPB_Instance_Proxy::OnHostMsgGetAudioHardwareOutputSampleRate(
     PP_Instance instance, uint32_t* result) {
-  EnterInstanceNoLock enter(instance, false);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
     *result = enter.functions()->GetAudioHardwareOutputSampleRate(instance);
 }
 
 void PPB_Instance_Proxy::OnHostMsgGetAudioHardwareOutputBufferSize(
     PP_Instance instance, uint32_t* result) {
-  EnterInstanceNoLock enter(instance, false);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
     *result = enter.functions()->GetAudioHardwareOutputBufferSize(instance);
 }
 
 void PPB_Instance_Proxy::OnHostMsgIsFullFrame(PP_Instance instance,
                                               PP_Bool* result) {
-  EnterInstanceNoLock enter(instance, false);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
     *result = enter.functions()->IsFullFrame(instance);
 }
 
 void PPB_Instance_Proxy::OnHostMsgExecuteScript(
     PP_Instance instance,
     SerializedVarReceiveInput script,
     SerializedVarOutParam out_exception,
     SerializedVarReturnValue result) {
-  EnterInstanceNoLock enter(instance, false);
+  EnterInstanceNoLock enter(instance);
   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::OnHostMsgGetDefaultCharSet(
     PP_Instance instance,
     SerializedVarReturnValue result) {
-  EnterInstanceNoLock enter(instance, false);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
     result.Return(dispatcher(), enter.functions()->GetDefaultCharSet(instance));
 }
 
 void PPB_Instance_Proxy::OnHostMsgSetFullscreen(PP_Instance instance,
                                                 PP_Bool fullscreen,
                                                 PP_Bool* result) {
-  EnterInstanceNoLock enter(instance, false);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
     *result = enter.functions()->SetFullscreen(instance, fullscreen);
 }
 
 
 void PPB_Instance_Proxy::OnHostMsgGetScreenSize(PP_Instance instance,
                                                 PP_Bool* result,
                                                 PP_Size* size) {
-  EnterInstanceNoLock enter(instance, false);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
     *result = enter.functions()->GetScreenSize(instance, size);
 }
 
 void PPB_Instance_Proxy::OnHostMsgRequestInputEvents(PP_Instance instance,
                                                      bool is_filtering,
                                                      uint32_t event_classes) {
-  EnterInstanceNoLock enter(instance, false);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     if (is_filtering)
       enter.functions()->RequestFilteringInputEvents(instance, event_classes);
     else
       enter.functions()->RequestInputEvents(instance, event_classes);
   }
 }
 
 void PPB_Instance_Proxy::OnHostMsgClearInputEvents(PP_Instance instance,
                                                    uint32_t event_classes) {
-  EnterInstanceNoLock enter(instance, false);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
     enter.functions()->ClearInputEventRequest(instance, event_classes);
 }
 
 void PPB_Instance_Proxy::OnMsgHandleInputEventAck(PP_Instance instance,
                                                   PP_TimeTicks timestamp) {
-  EnterInstanceNoLock enter(instance, false);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
     enter.functions()->ClosePendingUserGesture(instance, timestamp);
 }
 
 void PPB_Instance_Proxy::OnHostMsgPostMessage(
     PP_Instance instance,
     SerializedVarReceiveInput message) {
-  EnterInstanceNoLock enter(instance, false);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
     enter.functions()->PostMessage(instance, message.Get(dispatcher()));
 }
 
 void PPB_Instance_Proxy::OnHostMsgLockMouse(PP_Instance instance) {
   EnterHostFunctionForceCallback<PPB_Instance_FunctionAPI> enter(
       instance,
       callback_factory_.NewCallback(
           &PPB_Instance_Proxy::MouseLockCompleteInHost,
           instance));
   if (enter.succeeded())
     enter.SetResult(enter.functions()->LockMouse(instance, enter.callback()));
 }
 
 void PPB_Instance_Proxy::OnHostMsgUnlockMouse(PP_Instance instance) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, true);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded())
     enter.functions()->UnlockMouse(instance);
 }
 
 #if !defined(OS_NACL)
 void PPB_Instance_Proxy::OnHostMsgResolveRelativeToDocument(
     PP_Instance instance,
     SerializedVarReceiveInput relative,
     SerializedVarReturnValue result) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, true);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     result.Return(dispatcher(),
                   enter.functions()->ResolveRelativeToDocument(
                       instance, relative.Get(dispatcher()), NULL));
   }
 }
 
 void PPB_Instance_Proxy::OnHostMsgDocumentCanRequest(
     PP_Instance instance,
     SerializedVarReceiveInput url,
     PP_Bool* result) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, true);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     *result = enter.functions()->DocumentCanRequest(instance,
                                                     url.Get(dispatcher()));
   }
 }
 
 void PPB_Instance_Proxy::OnHostMsgDocumentCanAccessDocument(PP_Instance active,
                                                             PP_Instance target,
                                                             PP_Bool* result) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(active, true);
+  EnterInstanceNoLock enter(active);
   if (enter.succeeded())
     *result = enter.functions()->DocumentCanAccessDocument(active, target);
 }
 
 void PPB_Instance_Proxy::OnHostMsgGetDocumentURL(PP_Instance instance,
                                                  SerializedVarReturnValue result) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, true);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     result.Return(dispatcher(),
                   enter.functions()->GetDocumentURL(instance, NULL));
   }
 }
 
 void PPB_Instance_Proxy::OnHostMsgGetPluginInstanceURL(
     PP_Instance instance,
     SerializedVarReturnValue result) {
-  EnterFunctionNoLock<PPB_Instance_FunctionAPI> enter(instance, true);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     result.Return(dispatcher(),
                   enter.functions()->GetPluginInstanceURL(instance, NULL));
   }
 }
 #endif  // !defined(OS_NACL)
 
 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);
+  EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     enter.functions()->SetCursor(
         instance, static_cast<PP_MouseCursor_Type>(type),
         custom_image.host_resource(), &hot_spot);
   }
 }
 
+void PPB_Instance_Proxy::OnHostMsgSetTextInputType(PP_Instance instance,
+                                                   PP_TextInput_Type type) {
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded())
+    enter.functions()->SetTextInputType(instance, type);
+}
+
+void PPB_Instance_Proxy::OnHostMsgUpdateCaretPosition(
+    PP_Instance instance,
+    const PP_Rect& caret,
+    const PP_Rect& bounding_box) {
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded())
+    enter.functions()->UpdateCaretPosition(instance, caret, bounding_box);
+}
+
+void PPB_Instance_Proxy::OnHostMsgCancelCompositionText(PP_Instance instance) {
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded())
+    enter.functions()->CancelCompositionText(instance);
+}
+
+void PPB_Instance_Proxy::OnHostMsgUpdateSurroundingText(
+    PP_Instance instance,
+    const std::string& text,
+    uint32_t caret,
+    uint32_t anchor) {
+  EnterInstanceNoLock enter(instance);
+  if (enter.succeeded()) {
+    enter.functions()->UpdateSurroundingText(instance, text.c_str(), caret,
+                                             anchor);
+  }
+}
+
 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