Change Chromoting client to use Pepper's new Resource-base InputEvents.

remoting/client/plugin/chromoting_instance.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 "remoting/client/plugin/chromoting_instance.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task.h"
 #include "base/threading/thread.h"
 // TODO(sergeyu): We should not depend on renderer here. Instead P2P
 // Pepper API should be used. Remove this dependency.
 // crbug.com/74951
 #include "content/renderer/p2p/ipc_network_manager.h"
 #include "content/renderer/p2p/ipc_socket_factory.h"
-#include "ppapi/c/pp_input_event.h"
 #include "ppapi/cpp/completion_callback.h"
+#include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/rect.h"
 // TODO(wez): Remove this when crbug.com/86353 is complete.
 #include "ppapi/cpp/private/var_private.h"
 #include "remoting/client/client_config.h"
 #include "remoting/client/chromoting_client.h"
 #include "remoting/client/rectangle_update_decoder.h"
 #include "remoting/client/plugin/chromoting_scriptable_object.h"
 #include "remoting/client/plugin/pepper_client_logger.h"
 #include "remoting/client/plugin/pepper_input_handler.h"
 #include "remoting/client/plugin/pepper_port_allocator_session.h"
@@ skipping 14 matching lines @@
 #include "webkit/plugins/ppapi/resource_tracker.h"
 
 namespace remoting {
 
 const char* ChromotingInstance::kMimeType = "pepper-application/x-chromoting";
 
 ChromotingInstance::ChromotingInstance(PP_Instance pp_instance)
     : pp::InstancePrivate(pp_instance),
       initialized_(false),
       logger_(this) {
+  RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE | PP_INPUTEVENT_CLASS_WHEEL);
+  RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
 }
 
 ChromotingInstance::~ChromotingInstance() {
   DCHECK(CurrentlyOnPluginThread());
 
   if (client_.get()) {
     base::WaitableEvent done_event(true, false);
     client_->Stop(base::Bind(&base::WaitableEvent::Signal,
                              base::Unretained(&done_event)));
     done_event.Wait();
@@ skipping 94 matching lines @@
 
 void ChromotingInstance::DidChangeView(const pp::Rect& position,
                                        const pp::Rect& clip) {
   // This lets |view_| implement scale-to-fit. But it only specifies a
   // sub-rectangle of the plugin window as the rectangle on which the host
   // screen can be displayed, so |view_| has to make sure the plugin window
   // is large.
   view_->SetScreenSize(clip.width(), clip.height());
 }
 
-bool ChromotingInstance::HandleInputEvent(const PP_InputEvent& event) {
+bool ChromotingInstance::HandleInputEvent(const pp::InputEvent& event) {
   DCHECK(CurrentlyOnPluginThread());
 
   PepperInputHandler* pih
       = static_cast<PepperInputHandler*>(input_handler_.get());
 
-  switch (event.type) {
+  switch (event.GetType()) {
     case PP_INPUTEVENT_TYPE_MOUSEDOWN:
-      pih->HandleMouseButtonEvent(true, event.u.mouse);
+      pih->HandleMouseButtonEvent(true, pp::MouseInputEvent(event));
       return true;
 
     case PP_INPUTEVENT_TYPE_MOUSEUP:
-      pih->HandleMouseButtonEvent(false, event.u.mouse);
+      pih->HandleMouseButtonEvent(false, pp::MouseInputEvent(event));
       return true;
 
     case PP_INPUTEVENT_TYPE_MOUSEMOVE:
     case PP_INPUTEVENT_TYPE_MOUSEENTER:
     case PP_INPUTEVENT_TYPE_MOUSELEAVE:
-      pih->HandleMouseMoveEvent(event.u.mouse);
+      pih->HandleMouseMoveEvent(pp::MouseInputEvent(event));
       return true;
 
     case PP_INPUTEVENT_TYPE_CONTEXTMENU:
       // We need to return true here or else we'll get a local (plugin) context
       // menu instead of the mouseup event for the right click.
       return true;
 
     case PP_INPUTEVENT_TYPE_KEYDOWN:
     case PP_INPUTEVENT_TYPE_KEYUP:
-      logger_.VLog(3, "PP_INPUTEVENT_TYPE_KEY%s key=%d",
-                    (event.type==PP_INPUTEVENT_TYPE_KEYDOWN ? "DOWN" : "UP"),
-                    event.u.key.key_code);
-      pih->HandleKeyEvent(event.type == PP_INPUTEVENT_TYPE_KEYDOWN,
-                          event.u.key);
-      return true;
+      {
+        pp::KeyboardInputEvent key = pp::KeyboardInputEvent(event);
+        logger_.VLog(3, "PP_INPUTEVENT_TYPE_KEY%s key=%d",
+            (event.GetType()==PP_INPUTEVENT_TYPE_KEYDOWN ? "DOWN" : "UP"),

[dmac, 2011/07/20 00:34:31]

space between ) and ==

[garykac, 2011/07/20 18:55:28]

Done.

+            key.GetKeyCode());
+        pih->HandleKeyEvent(event.GetType() == PP_INPUTEVENT_TYPE_KEYDOWN, key);

[Wez, 2011/07/20 00:58:35]

nit: Why use event.GetType() == foo here, but not for MOUSEDOWN/MOUSEUP?

[garykac, 2011/07/20 18:55:28]

made consistent

+        return true;
+      }
 
     case PP_INPUTEVENT_TYPE_CHAR:
-      pih->HandleCharacterEvent(event.u.character);
+      pih->HandleCharacterEvent(pp::KeyboardInputEvent(event));
       return true;
 
     default:
+      LOG(INFO) << "Unhandled input event: " << event.GetType();
       break;
   }
 
   return false;
 }
 
 ChromotingScriptableObject* ChromotingInstance::GetScriptableObject() {
   pp::VarPrivate object = GetInstanceObject();
   if (!object.is_undefined()) {
     pp::deprecated::ScriptableObject* so = object.AsScriptableObject();
@@ skipping 59 matching lines @@
   if (!client_.get())
     return NULL;
   return client_->GetStats();
 }
 
 void ChromotingInstance::ReleaseAllKeys() {
   input_handler_->ReleaseAllKeys();
 }
 
 }  // namespace remoting