Remove all uses of the global Dispatcher Get function.

ppapi/proxy/ppb_var_deprecated_proxy.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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/ppb_var_deprecated_proxy.h"
 
 #include <stdlib.h>  // For malloc
 
 #include "base/logging.h"
 #include "ppapi/c/dev/ppb_var_deprecated.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
+#include "ppapi/proxy/plugin_var_tracker.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppp_class_proxy.h"
 #include "ppapi/proxy/serialized_var.h"
 
 namespace pp {
 namespace proxy {
 
 namespace {
 
+// Used to do get the set-up information for calling a var object. If the
+// exception is set, returns NULL. Otherwise, computes the dispatcher for the
+// given var object. If the var is not a valid object, returns NULL and sets
+// the exception.
+PluginDispatcher* CheckExceptionAndGetDispatcher(const PP_Var& object,
+                                                 PP_Var* exception) {
+  // If an exception is already set, we don't need to do anything, just return
+  // an error to the caller.
+  if (exception && exception->type != PP_VARTYPE_UNDEFINED)
+    return NULL;
+
+  PluginVarTracker* tracker = PluginVarTracker::GetInstance();
+  PluginDispatcher* dispatcher = tracker->DispatcherForPluginObject(object);
+  if (dispatcher)
+    return dispatcher;
+
+  // The object is invalid. This means we can't figure out which dispatcher
+  // to use, which is OK because the call will fail anyway. Set the exception.
+  if (exception) {
+    exception->type = PP_VARTYPE_STRING;
+    exception->value.as_id =
+        tracker->MakeString("Attempting to use an invalid object");
+  }
+  return NULL;
+}
+
 // PPP_Var_Deprecated plugin ---------------------------------------------------
 
 void AddRefVar(PP_Var var) {
   PluginVarTracker::GetInstance()->AddRef(var);
 }
 
 void ReleaseVar(PP_Var var) {
   PluginVarTracker::GetInstance()->Release(var);
 }
 
@@ skipping 12 matching lines @@
     *len = static_cast<uint32_t>(str->size());
     return str->c_str();
   }
   *len = 0;
   return NULL;
 }
 
 bool HasProperty(PP_Var var,
                  PP_Var name,
                  PP_Var* exception) {
-  Dispatcher* dispatcher = PluginDispatcher::Get();
+  Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
+  if (!dispatcher)
+    return false;
+
   ReceiveSerializedException se(dispatcher, exception);
   PP_Bool result = PP_FALSE;
   if (!se.IsThrown()) {
     dispatcher->Send(new PpapiHostMsg_PPBVar_HasProperty(
         INTERFACE_ID_PPB_VAR_DEPRECATED,
         SerializedVarSendInput(dispatcher, var),
         SerializedVarSendInput(dispatcher, name), &se, &result));
   }
   return PPBoolToBool(result);
 }
 
 bool HasMethod(PP_Var var,
                PP_Var name,
                PP_Var* exception) {
-  Dispatcher* dispatcher = PluginDispatcher::Get();
+  Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
+  if (!dispatcher)
+    return false;
+
   ReceiveSerializedException se(dispatcher, exception);
   PP_Bool result = PP_FALSE;
   if (!se.IsThrown()) {
     dispatcher->Send(new PpapiHostMsg_PPBVar_HasMethodDeprecated(
         INTERFACE_ID_PPB_VAR_DEPRECATED,
         SerializedVarSendInput(dispatcher, var),
         SerializedVarSendInput(dispatcher, name), &se, &result));
   }
   return PPBoolToBool(result);
 }
 
 PP_Var GetProperty(PP_Var var,
                    PP_Var name,
                    PP_Var* exception) {
-  Dispatcher* dispatcher = PluginDispatcher::Get();
+  Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
+  if (!dispatcher)
+    return PP_MakeUndefined();
+
   ReceiveSerializedException se(dispatcher, exception);
   ReceiveSerializedVarReturnValue result;
   if (!se.IsThrown()) {
     dispatcher->Send(new PpapiHostMsg_PPBVar_GetProperty(
         INTERFACE_ID_PPB_VAR_DEPRECATED,
         SerializedVarSendInput(dispatcher, var),
         SerializedVarSendInput(dispatcher, name), &se, &result));
   }
   return result.Return(dispatcher);
 }
 
 void EnumerateProperties(PP_Var var,
                          uint32_t* property_count,
                          PP_Var** properties,
                          PP_Var* exception) {
-  Dispatcher* dispatcher = PluginDispatcher::Get();
+  Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
+  if (!dispatcher) {
+    *property_count = 0;
+    *properties = NULL;
+    return;
+  }
 
   ReceiveSerializedVarVectorOutParam out_vector(dispatcher,
                                                 property_count, properties);
   ReceiveSerializedException se(dispatcher, exception);
   if (!se.IsThrown()) {
     dispatcher->Send(new PpapiHostMsg_PPBVar_EnumerateProperties(
         INTERFACE_ID_PPB_VAR_DEPRECATED,
         SerializedVarSendInput(dispatcher, var),
         out_vector.OutParam(), &se));
   }
 }
 
 void SetProperty(PP_Var var,
                  PP_Var name,
                  PP_Var value,
                  PP_Var* exception) {
-  Dispatcher* dispatcher = PluginDispatcher::Get();
+  Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
+  if (!dispatcher)
+    return;
+
   ReceiveSerializedException se(dispatcher, exception);
   if (!se.IsThrown()) {
     dispatcher->Send(new PpapiHostMsg_PPBVar_SetPropertyDeprecated(
         INTERFACE_ID_PPB_VAR_DEPRECATED,
         SerializedVarSendInput(dispatcher, var),
         SerializedVarSendInput(dispatcher, name),
         SerializedVarSendInput(dispatcher, value), &se));
   }
 }
 
 void RemoveProperty(PP_Var var,
                     PP_Var name,
                     PP_Var* exception) {
-  Dispatcher* dispatcher = PluginDispatcher::Get();
+  Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, exception);
+  if (!dispatcher)
+    return;
+
   ReceiveSerializedException se(dispatcher, exception);
   PP_Bool result = PP_FALSE;
   if (!se.IsThrown()) {
     dispatcher->Send(new PpapiHostMsg_PPBVar_DeleteProperty(
         INTERFACE_ID_PPB_VAR_DEPRECATED,
         SerializedVarSendInput(dispatcher, var),
         SerializedVarSendInput(dispatcher, name), &se, &result));
   }
 }
 
 PP_Var Call(PP_Var object,
             PP_Var method_name,
             uint32_t argc,
             PP_Var* argv,
             PP_Var* exception) {
-  Dispatcher* dispatcher = PluginDispatcher::Get();
+  Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(object, exception);
+  if (!dispatcher)
+    return PP_MakeUndefined();
+
   ReceiveSerializedVarReturnValue result;
   ReceiveSerializedException se(dispatcher, exception);
   if (!se.IsThrown()) {
     std::vector<SerializedVar> argv_vect;
     SerializedVarSendInput::ConvertVector(dispatcher, argv, argc, &argv_vect);
 
     dispatcher->Send(new PpapiHostMsg_PPBVar_CallDeprecated(
         INTERFACE_ID_PPB_VAR_DEPRECATED,
         SerializedVarSendInput(dispatcher, object),
         SerializedVarSendInput(dispatcher, method_name), argv_vect,
         &se, &result));
   }
   return result.Return(dispatcher);
 }
 
 PP_Var Construct(PP_Var object,
                  uint32_t argc,
                  PP_Var* argv,
                  PP_Var* exception) {
-  Dispatcher* dispatcher = PluginDispatcher::Get();
+  Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(object, exception);
+  if (!dispatcher)
+    return PP_MakeUndefined();
+
   ReceiveSerializedVarReturnValue result;
   ReceiveSerializedException se(dispatcher, exception);
   if (!se.IsThrown()) {
     std::vector<SerializedVar> argv_vect;
     SerializedVarSendInput::ConvertVector(dispatcher, argv, argc, &argv_vect);
 
     dispatcher->Send(new PpapiHostMsg_PPBVar_Construct(
         INTERFACE_ID_PPB_VAR_DEPRECATED,
         SerializedVarSendInput(dispatcher, object),
         argv_vect, &se, &result));
   }
   return result.Return(dispatcher);
 }
 
 bool IsInstanceOf(PP_Var var,
-                     const PPP_Class_Deprecated* ppp_class,
-                     void** ppp_class_data) {
+                  const PPP_Class_Deprecated* ppp_class,
+                  void** ppp_class_data) {
+  Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, NULL);
+  if (!dispatcher)
+    return false;
+
   PP_Bool result = PP_FALSE;
-  Dispatcher* dispatcher = PluginDispatcher::Get();
   int64 class_int = static_cast<int64>(reinterpret_cast<intptr_t>(ppp_class));
   int64 class_data_int = 0;
   dispatcher->Send(new PpapiHostMsg_PPBVar_IsInstanceOfDeprecated(
       INTERFACE_ID_PPB_VAR_DEPRECATED, SerializedVarSendInput(dispatcher, var),
       class_int, &class_data_int, &result));
   *ppp_class_data =
       reinterpret_cast<void*>(static_cast<intptr_t>(class_data_int));
   return PPBoolToBool(result);
 }
 
 PP_Var CreateObject(PP_Instance instance,
                     const PPP_Class_Deprecated* ppp_class,
                     void* ppp_class_data) {
-  Dispatcher* dispatcher = PluginDispatcher::Get();
+  Dispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
+  if (!dispatcher)
+    return PP_MakeUndefined();
+
   ReceiveSerializedVarReturnValue result;
   int64 class_int = static_cast<int64>(reinterpret_cast<intptr_t>(ppp_class));
   int64 data_int =
       static_cast<int64>(reinterpret_cast<intptr_t>(ppp_class_data));
   dispatcher->Send(new PpapiHostMsg_PPBVar_CreateObjectDeprecated(
       INTERFACE_ID_PPB_VAR_DEPRECATED, instance, class_int, data_int,
       &result));
   return result.Return(dispatcher);
 }
 
 const PPB_Var_Deprecated var_deprecated_interface = {
   &AddRefVar,
   &ReleaseVar,
   &VarFromUtf8,
   &VarToUtf8,
   &HasProperty,
   &HasMethod,
   &GetProperty,
   &EnumerateProperties,
   &SetProperty,
   &RemoveProperty,
   &Call,
   &Construct,
   &IsInstanceOf,
   &CreateObject
 };
 
+InterfaceProxy* CreateVarDeprecatedProxy(Dispatcher* dispatcher,
+                                         const void* target_interface) {
+  return new PPB_Var_Deprecated_Proxy(dispatcher, target_interface);
+}
+
 }  // namespace
 
 PPB_Var_Deprecated_Proxy::PPB_Var_Deprecated_Proxy(
     Dispatcher* dispatcher,
     const void* target_interface)
     : InterfaceProxy(dispatcher, target_interface) {
 }
 
 PPB_Var_Deprecated_Proxy::~PPB_Var_Deprecated_Proxy() {
 }
 
-const void* PPB_Var_Deprecated_Proxy::GetSourceInterface() const {
-  return &var_deprecated_interface;
-}
-
-InterfaceID PPB_Var_Deprecated_Proxy::GetInterfaceId() const {
-  return INTERFACE_ID_PPB_VAR_DEPRECATED;
+// static
+const InterfaceProxy::Info* PPB_Var_Deprecated_Proxy::GetInfo() {
+  static const Info info = {
+    &var_deprecated_interface,
+    PPB_VAR_DEPRECATED_INTERFACE,
+    INTERFACE_ID_PPB_VAR_DEPRECATED,
+    false,
+    &CreateVarDeprecatedProxy,
+  };
+  return &info;
 }
 
 bool PPB_Var_Deprecated_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_Var_Deprecated_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_HasProperty,
                         OnMsgHasProperty)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_HasMethodDeprecated,
                         OnMsgHasMethodDeprecated)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_GetProperty,
@@ skipping 122 matching lines @@
     PP_Instance instance,
     int64 ppp_class,
     int64 class_data,
     SerializedVarReturnValue result) {
   result.Return(dispatcher(), PPP_Class_Proxy::CreateProxiedObject(
       ppb_var_target(), dispatcher(), instance, ppp_class, class_data));
 }
 
 }  // namespace proxy
 }  // namespace pp