Remove HandleInputEvent from PPP_Instance and freeze to 1.0.

webkit/plugins/ppapi/ppapi_plugin_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 "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 182 matching lines @@
                                           PluginModule* module,
                                           const void* ppp_instance_if_0_5) {
   const PPP_Instance_0_5* interface =
       static_cast<const PPP_Instance_0_5*>(ppp_instance_if_0_5);
   return new PluginInstance(
       delegate,
       module,
       new ::ppapi::PPP_Instance_Combined(*interface));
 }
 
+// static
+PluginInstance* PluginInstance::Create1_0(PluginDelegate* delegate,
+                                          PluginModule* module,
+                                          const void* ppp_instance_if_1_0) {
+  const PPP_Instance_1_0* interface =
+      static_cast<const PPP_Instance_1_0*>(ppp_instance_if_1_0);
+  return new PluginInstance(
+      delegate,
+      module,
+      new ::ppapi::PPP_Instance_Combined(*interface));
+}
+
 PluginInstance::PluginInstance(
     PluginDelegate* delegate,
     PluginModule* module,
     ::ppapi::PPP_Instance_Combined* instance_interface)
     : delegate_(delegate),
       module_(module),
       instance_interface_(instance_interface),
       pp_instance_(0),
       container_(NULL),
       full_frame_(false),
@@ skipping 199 matching lines @@
 
   size_t argc = 0;
   scoped_array<const char*> argn(new const char*[arg_names.size()]);
   scoped_array<const char*> argv(new const char*[arg_names.size()]);
   for (size_t i = 0; i < arg_names.size(); ++i) {
     argn[argc] = arg_names[i].c_str();
     argv[argc] = arg_values[i].c_str();
     argc++;
   }
 
-  return PPBoolToBool(instance_interface_->DidCreate(pp_instance(),
-                                                     argc,
-                                                     argn.get(),
-                                                     argv.get()));
+  return PP_ToBool(instance_interface_->DidCreate(pp_instance(),
+                                                  argc,
+                                                  argn.get(),
+                                                  argv.get()));
 }
 
 bool PluginInstance::HandleDocumentLoad(PPB_URLLoader_Impl* loader) {
   Resource::ScopedResourceId resource(loader);
-  return PPBoolToBool(instance_interface_->HandleDocumentLoad(pp_instance(),
-                                                              resource.id));
+  return PP_ToBool(instance_interface_->HandleDocumentLoad(pp_instance(),
+                                                           resource.id));
 }
 
 bool PluginInstance::HandleInputEvent(const WebKit::WebInputEvent& event,
                                       WebCursorInfo* cursor_info) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
 
   bool rv = false;
   if (LoadInputEventInterface()) {
     PP_InputEvent_Class event_class = ClassifyInputEvent(event.type);
@@ skipping 10 matching lines @@
       ResourceTracker* tracker = ResourceTracker::Get();
       for (size_t i = 0; i < events.size(); i++) {
         if (filtered_input_event_mask_ & event_class)
           events[i].is_filtered = true;
         else
           rv = true;  // Unfiltered events are assumed to be handled.
         scoped_refptr<PPB_InputEvent_Impl> event_resource(
             new PPB_InputEvent_Impl(this, events[i]));
         PP_Resource resource = event_resource->GetReference();
 
-        rv |= PPBoolToBool(plugin_input_event_interface_->HandleInputEvent(
+        rv |= PP_ToBool(plugin_input_event_interface_->HandleInputEvent(
             pp_instance(), event_resource->GetReference()));
 
         // Release the reference we took above.
         tracker->UnrefResource(resource);
       }
     }
   }
 
-  // For compatibility, also send all input events through the old interface.
+  // For compatibility, also send all input events through the old interface,
+  // if it exists.
   // TODO(brettw) remove this.
-  std::vector<PP_InputEvent> pp_events;
-  CreatePPEvent(event, &pp_events);
+  if (instance_interface_->HandleInputEvent_0_5) {
+    std::vector<PP_InputEvent> pp_events;
+    CreatePPEvent(event, &pp_events);
 
-  // Each input event may generate more than one PP_InputEvent.
-  for (size_t i = 0; i < pp_events.size(); i++) {
-    rv |= PPBoolToBool(instance_interface_->HandleInputEvent(pp_instance(),
-                                                             &pp_events[i]));
+    // Each input event may generate more than one PP_InputEvent.
+    for (size_t i = 0; i < pp_events.size(); i++) {
+      rv |= PP_ToBool(
+          instance_interface_->HandleInputEvent_0_5(pp_instance(),
+                                                    &pp_events[i]));
+    }
   }
 
   if (cursor_.get())
     *cursor_info = *cursor_;
   return rv;
 }
 
 void PluginInstance::HandleMessage(PP_Var message) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
@@ skipping 36 matching lines @@
 
 void PluginInstance::SetWebKitFocus(bool has_focus) {
   if (has_webkit_focus_ == has_focus)
     return;
 
   bool old_plugin_focus = PluginHasFocus();
   has_webkit_focus_ = has_focus;
   if (PluginHasFocus() != old_plugin_focus) {
     delegate()->PluginFocusChanged(PluginHasFocus());
     instance_interface_->DidChangeFocus(pp_instance(),
-                                        BoolToPPBool(PluginHasFocus()));
+                                        PP_FromBool(PluginHasFocus()));
   }
 }
 
 void PluginInstance::SetContentAreaFocus(bool has_focus) {
   if (has_content_area_focus_ == has_focus)
     return;
 
   bool old_plugin_focus = PluginHasFocus();
   has_content_area_focus_ = has_focus;
   if (PluginHasFocus() != old_plugin_focus) {
     instance_interface_->DidChangeFocus(pp_instance(),
-                                        BoolToPPBool(PluginHasFocus()));
+                                        PP_FromBool(PluginHasFocus()));
   }
 }
 
 void PluginInstance::ViewInitiatedPaint() {
   if (GetBoundGraphics2D())
     GetBoundGraphics2D()->ViewInitiatedPaint();
   else if (GetBoundGraphics3D())
     GetBoundGraphics3D()->ViewInitiatedPaint();
   else if (GetBoundSurface3D())
     GetBoundSurface3D()->ViewInitiatedPaint();
@@ skipping 39 matching lines @@
   return true;
 }
 
 string16 PluginInstance::GetSelectedText(bool html) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   if (!LoadSelectionInterface())
     return string16();
 
   PP_Var rv = plugin_selection_interface_->GetSelectedText(pp_instance(),
-                                                           BoolToPPBool(html));
+                                                           PP_FromBool(html));
   scoped_refptr<StringVar> string(StringVar::FromPPVar(rv));
   Var::PluginReleasePPVar(rv);  // Release the ref the plugin transfered to us.
   if (!string)
     return string16();
   return UTF8ToUTF16(string->value());
 }
 
 string16 PluginInstance::GetLinkAtPosition(const gfx::Point& point) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   if (!LoadPdfInterface())
     return string16();
 
   PP_Point p;
   p.x = point.x();
   p.y = point.y();
   PP_Var rv = plugin_pdf_interface_->GetLinkAtPosition(pp_instance(), p);
   scoped_refptr<StringVar> string(StringVar::FromPPVar(rv));
   Var::PluginReleasePPVar(rv);  // Release the ref the plugin transfered to us.
   if (!string)
     return string16();
   return UTF8ToUTF16(string->value());
 }
 
 void PluginInstance::Zoom(double factor, bool text_only) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   if (!LoadZoomInterface())
     return;
-  plugin_zoom_interface_->Zoom(pp_instance(), factor, BoolToPPBool(text_only));
+  plugin_zoom_interface_->Zoom(pp_instance(), factor, PP_FromBool(text_only));
 }
 
 bool PluginInstance::StartFind(const string16& search_text,
                                bool case_sensitive,
                                int identifier) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   if (!LoadFindInterface())
     return false;
   find_identifier_ = identifier;
-  return PPBoolToBool(
+  return PP_ToBool(
       plugin_find_interface_->StartFind(
           pp_instance(),
           UTF16ToUTF8(search_text.c_str()).c_str(),
-          BoolToPPBool(case_sensitive)));
+          PP_FromBool(case_sensitive)));
 }
 
 void PluginInstance::SelectFindResult(bool forward) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   if (LoadFindInterface())
     plugin_find_interface_->SelectFindResult(pp_instance(),
-                                             BoolToPPBool(forward));
+                                             PP_FromBool(forward));
 }
 
 void PluginInstance::StopFind() {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   if (!LoadFindInterface())
     return;
   find_identifier_ = -1;
   plugin_find_interface_->StopFind(pp_instance());
 }
@@ skipping 823 matching lines @@
 }
 
 PP_Bool PluginInstance::IsFullscreen(PP_Instance instance) {
   return PP_FromBool(fullscreen_);
 }
 
 PP_Bool PluginInstance::SetFullscreen(PP_Instance instance,
                                       PP_Bool fullscreen) {
   // TODO(yzshen): Re-enable it once fullscreen mode is supported on Windows.
 #if !defined(OS_WIN)
-  SetFullscreen(PPBoolToBool(fullscreen), true);
+  SetFullscreen(PP_ToBool(fullscreen), true);
   return PP_TRUE;
 #else
   return PP_FALSE;
 #endif
 }
 
 PP_Bool PluginInstance::GetScreenSize(PP_Instance instance, PP_Size* size) {
   gfx::Size screen_size = delegate()->GetScreenSize();
   *size = PP_MakeSize(screen_size.width(), screen_size.height());
   return PP_TRUE;
@@ skipping 54 matching lines @@
   }
   delegate()->ZoomLimitsChanged(minimum_factor, maximium_factor);
 }
 
 void PluginInstance::PostMessage(PP_Instance instance, PP_Var message) {
   message_channel_->PostMessageToJavaScript(message);
 }
 
 }  // namespace ppapi
 }  // namespace webkit