Make o.o.p. proxy handle PPP_Instance versions 0.4 and 0.5.

ppapi/proxy/ppp_instance_proxy.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 "ppapi/proxy/ppp_instance_proxy.h"
 
 #include <algorithm>
 
 #include "ppapi/c/dev/ppb_fullscreen_dev.h"
 #include "ppapi/c/pp_var.h"
@@ skipping 102 matching lines @@
 }
 
 PP_Var GetInstanceObject(PP_Instance instance) {
   Dispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   ReceiveSerializedVarReturnValue result;
   dispatcher->Send(new PpapiMsg_PPPInstance_GetInstanceObject(
       INTERFACE_ID_PPP_INSTANCE, instance, &result));
   return result.Return(dispatcher);
 }
 
-static const PPP_Instance instance_interface = {
+static const PPP_Instance_0_4 instance_interface_0_4 = {
   &DidCreate,
   &DidDestroy,
   &DidChangeView,
   &DidChangeFocus,
   &HandleInputEvent,
   &HandleDocumentLoad,
   &GetInstanceObject
 };
 
+static const PPP_Instance_0_5 instance_interface_0_5 = {
+  &DidCreate,
+  &DidDestroy,
+  &DidChangeView,
+  &DidChangeFocus,
+  &HandleInputEvent,
+  &HandleDocumentLoad
+};
+
+template <class PPP_Instance_Type>
 InterfaceProxy* CreateInstanceProxy(Dispatcher* dispatcher,
                                     const void* target_interface) {
-  return new PPP_Instance_Proxy(dispatcher, target_interface);
+  return new PPP_Instance_Proxy(
+      dispatcher,
+      static_cast<const PPP_Instance_Type*>(target_interface));
 }
 
 }  // namespace
 
-PPP_Instance_Proxy::PPP_Instance_Proxy(Dispatcher* dispatcher,
-                                       const void* target_interface)
-    : InterfaceProxy(dispatcher, target_interface) {
-}
-
 PPP_Instance_Proxy::~PPP_Instance_Proxy() {
 }
 
 // static
-const InterfaceProxy::Info* PPP_Instance_Proxy::GetInfo() {
+const InterfaceProxy::Info* PPP_Instance_Proxy::GetInfo0_4() {
   static const Info info = {
-    &instance_interface,
-    PPP_INSTANCE_INTERFACE,
+    &instance_interface_0_4,
+    PPP_INSTANCE_INTERFACE_0_4,
     INTERFACE_ID_PPP_INSTANCE,
     false,
-    &CreateInstanceProxy,
+    &CreateInstanceProxy<PPP_Instance_0_4>
   };
   return &info;
 }
+
+// static
+const InterfaceProxy::Info* PPP_Instance_Proxy::GetInfo0_5() {
+  static const Info info = {
+    &instance_interface_0_5,
+    PPP_INSTANCE_INTERFACE_0_5,
+    INTERFACE_ID_PPP_INSTANCE,
+    false,
+    &CreateInstanceProxy<PPP_Instance_0_5>,
+  };
+  return &info;
+}
 
 bool PPP_Instance_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPP_Instance_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPInstance_DidCreate,
                         OnMsgDidCreate)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPInstance_DidDestroy,
                         OnMsgDidDestroy)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPInstance_DidChangeView,
                         OnMsgDidChangeView)
@@ skipping 30 matching lines @@
   // address below.
   std::vector<const char*> argn_array(
       std::max(static_cast<size_t>(1), argn.size()));
   std::vector<const char*> argv_array(
       std::max(static_cast<size_t>(1), argn.size()));
   for (size_t i = 0; i < argn.size(); i++) {
     argn_array[i] = argn[i].c_str();
     argv_array[i] = argv[i].c_str();
   }
 
-  DCHECK(ppp_instance_target());
-  *result = ppp_instance_target()->DidCreate(instance,
-                                             static_cast<uint32_t>(argn.size()),
-                                             &argn_array[0], &argv_array[0]);
+  DCHECK(combined_interface_.get());
+  *result = combined_interface_->DidCreate(instance,
+                                           static_cast<uint32_t>(argn.size()),
+                                           &argn_array[0], &argv_array[0]);
 }
 
 void PPP_Instance_Proxy::OnMsgDidDestroy(PP_Instance instance) {
-  ppp_instance_target()->DidDestroy(instance);
+  combined_interface_->DidDestroy(instance);
   static_cast<PluginDispatcher*>(dispatcher())->DidDestroyInstance(instance);
 }
 
 void PPP_Instance_Proxy::OnMsgDidChangeView(PP_Instance instance,
                                             const PP_Rect& position,
                                             const PP_Rect& clip,
                                             PP_Bool fullscreen) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return;
   InstanceData* data = dispatcher->GetInstanceData(instance);
   if (!data)
     return;
   data->position = position;
   data->fullscreen = fullscreen;
-  ppp_instance_target()->DidChangeView(instance, &position, &clip);
+  combined_interface_->DidChangeView(instance, &position, &clip);
 }
 
 void PPP_Instance_Proxy::OnMsgDidChangeFocus(PP_Instance instance,
                                              PP_Bool has_focus) {
-  ppp_instance_target()->DidChangeFocus(instance, has_focus);
+  combined_interface_->DidChangeFocus(instance, has_focus);
 }
 
 void PPP_Instance_Proxy::OnMsgHandleInputEvent(PP_Instance instance,
                                                const PP_InputEvent& event,
                                                PP_Bool* result) {
-  *result = ppp_instance_target()->HandleInputEvent(instance, &event);
+  *result = combined_interface_->HandleInputEvent(instance, &event);
 }
 
 void PPP_Instance_Proxy::OnMsgHandleDocumentLoad(PP_Instance instance,
                                                  const HostResource& url_loader,
                                                  PP_Bool* result) {
   PP_Resource plugin_loader =
       PPB_URLLoader_Proxy::TrackPluginResource(url_loader);
-  *result = ppp_instance_target()->HandleDocumentLoad(
-      instance, plugin_loader);
+  *result = combined_interface_->HandleDocumentLoad(instance, plugin_loader);
 
   // This balances the one reference that TrackPluginResource() initialized it
   // with. The plugin will normally take an additional reference which will keep
   // the resource alive in the plugin (and the one reference in the renderer
   // representing all plugin references).
   // Once all references at the plugin side are released, the renderer side will
   // be notified and release the reference added in HandleDocumentLoad() above.
   PluginResourceTracker::GetInstance()->ReleaseResource(plugin_loader);
 }
 
 void PPP_Instance_Proxy::OnMsgGetInstanceObject(
     PP_Instance instance,
     SerializedVarReturnValue result) {
+  // GetInstanceObject_0_4 can be null if we're talking to version 0.5 or later,
+  // however the host side of the proxy should never call this function on an
+  // 0.5 or later version.
+  DCHECK(combined_interface_->GetInstanceObject_0_4);
   result.Return(dispatcher(),
-                ppp_instance_target()->GetInstanceObject(instance));
+                combined_interface_->GetInstanceObject_0_4(instance));
 }
 
 }  // namespace proxy
 }  // namespace pp