Revert 93202 - Remove HandleInputEvent from PPP_Instance and freeze to 1.0.

ppapi/proxy/ppp_instance_proxy_test.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 "base/synchronization/waitable_event.h"
 #include "ipc/ipc_message_utils.h"
 #include "ppapi/c/dev/ppb_fullscreen_dev.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppb_url_loader.h"
@@ skipping 42 matching lines @@
 }
 
 PP_Bool received_has_focus;
 base::WaitableEvent did_change_focus_called(false, false);
 void DidChangeFocus(PP_Instance instance, PP_Bool has_focus) {
   received_instance = instance;
   received_has_focus = has_focus;
   did_change_focus_called.Signal();
 }
 
+PP_InputEvent received_event;
+PP_Bool HandleInputEvent(PP_Instance instance, const PP_InputEvent* event) {
+  received_instance = instance;
+  memcpy(&received_event, event, sizeof(*event));;
+  return bool_to_return;
+}
+
 PP_Bool HandleDocumentLoad(PP_Instance instance, PP_Resource url_loader) {
   // This one requires use of the PPB_URLLoader proxy and PPB_Core, plus a
   // resource tracker for the url_loader resource.
   // TODO(dmichael): Mock those out and test this function.
   NOTREACHED();
   return PP_FALSE;
 }
 
 PP_Var var_to_return;
 PP_Var GetInstanceObject(PP_Instance instance) {
   received_instance = instance;
   return var_to_return;
 }
 
 // Clear all the 'received' values for our mock.  Call this before you expect
 // one of the functions to be invoked.  TODO(dmichael): It would be better to
 // have a flag also for each function, so we know the right one got called.
 void ResetReceived() {
   received_instance = 0;
   received_argc = 0;
   received_argn.clear();
   received_argv.clear();
   memset(&received_position, 0, sizeof(received_position));
   memset(&received_clip, 0, sizeof(received_clip));
   received_has_focus = PP_FALSE;
+  memset(&received_event, 0, sizeof(received_event));
 }
 
-PPP_Instance_1_0 ppp_instance_1_0 = {
+PPP_Instance_0_5 ppp_instance_0_5 = {
   &DidCreate,
   &DidDestroy,
   &DidChangeView,
   &DidChangeFocus,
+  &HandleInputEvent,
   &HandleDocumentLoad
 };
 
 // PPP_Instance_Proxy::DidChangeView relies on PPB_FullscreenDev being
 // available with a valid implementation of IsFullScreen, so we mock it.
 PP_Bool IsFullscreen(PP_Instance instance) {
   return PP_FALSE;
 }
 PPB_Fullscreen_Dev ppb_fullscreen_dev = { &IsFullscreen };
 
 }  // namespace
 
 class PPP_Instance_ProxyTest : public TwoWayTest {
  public:
    PPP_Instance_ProxyTest()
        : TwoWayTest(TwoWayTest::TEST_PPP_INTERFACE) {
    }
 };
 
-TEST_F(PPP_Instance_ProxyTest, PPPInstance1_0) {
-  plugin().RegisterTestInterface(PPP_INSTANCE_INTERFACE_1_0, &ppp_instance_1_0);
+TEST_F(PPP_Instance_ProxyTest, PPPInstance0_5) {
+  plugin().RegisterTestInterface(PPP_INSTANCE_INTERFACE_0_5, &ppp_instance_0_5);
   host().RegisterTestInterface(PPB_FULLSCREEN_DEV_INTERFACE,
                                &ppb_fullscreen_dev);
 
-  // Grab the host-side proxy for the 1.0 interface.
-  const PPP_Instance_1_0* ppp_instance = static_cast<const PPP_Instance_1_0*>(
+  // Grab the host-side proxy for the 0.5 interface.
+  const PPP_Instance_0_5* ppp_instance = static_cast<const PPP_Instance_0_5*>(
       host().host_dispatcher()->GetProxiedInterface(
-          PPP_INSTANCE_INTERFACE_1_0));
+          PPP_INSTANCE_INTERFACE_0_5));
 
   // Call each function in turn, make sure we get the expected values and
   // returns.
   //
   // We don't test DidDestroy, because it has the side-effect of removing the
   // PP_Instance from the PluginDispatcher, which will cause a failure later
   // when the test is torn down.
   PP_Instance expected_instance = pp_instance();
   std::vector<std::string> expected_argn, expected_argv;
   expected_argn.push_back("Hello");
@@ skipping 34 matching lines @@
   EXPECT_EQ(received_clip.size.width, expected_clip.size.width);
   EXPECT_EQ(received_clip.size.height, expected_clip.size.height);
 
   PP_Bool expected_has_focus = PP_TRUE;
   ResetReceived();
   ppp_instance->DidChangeFocus(expected_instance, expected_has_focus);
   did_change_focus_called.Wait();
   EXPECT_EQ(received_instance, expected_instance);
   EXPECT_EQ(received_has_focus, expected_has_focus);
 
+  PP_InputEvent expected_event = { PP_INPUTEVENT_TYPE_KEYDOWN,  // type
+                                   0,  // padding
+                                   1.0,  // time_stamp
+                                   { { 2, 3 } } };  // u (as PP_InputEvent_Key)
+  ResetReceived();
+  EXPECT_EQ(bool_to_return,
+            ppp_instance->HandleInputEvent(expected_instance, &expected_event));
+  EXPECT_EQ(received_instance, expected_instance);
+  ASSERT_EQ(received_event.type, expected_event.type);
+  // Ignore padding; it's okay if it's not serialized.
+  EXPECT_EQ(received_event.time_stamp, expected_event.time_stamp);
+  EXPECT_EQ(received_event.u.key.modifier, expected_event.u.key.modifier);
+  EXPECT_EQ(received_event.u.key.key_code, expected_event.u.key.key_code);
+
   //  TODO(dmichael): Need to mock out a resource Tracker to be able to test
   //                  HandleResourceLoad. It also requires
   //                  PPB_Core.AddRefResource and for PPB_URLLoader to be
   //                  registered.
 }
 
 }  // namespace proxy
 }  // namespace pp