Remove all uses of the global Dispatcher Get function.

ppapi/proxy/plugin_var_tracker.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/plugin_var_tracker.h"
 
 #include "base/ref_counted.h"
 #include "base/singleton.h"
 #include "ppapi/c/ppb_var.h"
+#include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/interface_id.h"
 
 namespace pp {
 namespace proxy {
 
 namespace {
 
 // When non-NULL, this object overrides the VarTrackerSingleton.
 PluginVarTracker* var_tracker_override = NULL;
@@ skipping 15 matching lines @@
 };
 
 // When running in the plugin, this will convert the string ID to the object
 // using casting. No validity checking is done.
 RefCountedString* PluginStringFromID(PluginVarTracker::VarID id) {
   return reinterpret_cast<RefCountedString*>(static_cast<intptr_t>(id));
 }
 
 }  // namespace
 
-PluginVarTracker::HostVar::HostVar(Sender* d, VarID i)
-    : channel(d),
+PluginVarTracker::HostVar::HostVar(PluginDispatcher* d, VarID i)
+    : dispatcher(d),
       host_object_id(i) {
 }
 
 bool PluginVarTracker::HostVar::operator<(const HostVar& other) const {
-  if (channel < other.channel)
+  if (dispatcher < other.dispatcher)
     return true;
-  if (other.channel < channel)
+  if (other.dispatcher < dispatcher)
     return false;
   return host_object_id < other.host_object_id;
 }
 
 PluginVarTracker::PluginVarInfo::PluginVarInfo(const HostVar& host_var)
     : host_var(host_var),
       ref_count(0),
       track_with_no_reference_count(0) {
 }
 
@@ skipping 78 matching lines @@
     }
 
     info.ref_count--;
     if (info.ref_count == 0)
       SendReleaseObjectMsg(info.host_var);
     DeletePluginVarInfoIfNecessary(found);
   }
 }
 
 PP_Var PluginVarTracker::ReceiveObjectPassRef(const PP_Var& var,
-                                              Sender* channel) {
+                                              PluginDispatcher* dispatcher) {
   DCHECK(var.type == PP_VARTYPE_OBJECT);
 
   // Find the plugin info.
   PluginVarInfoMap::iterator found =
-      FindOrMakePluginVarFromHostVar(var, channel);
+      FindOrMakePluginVarFromHostVar(var, dispatcher);
   if (found == plugin_var_info_.end()) {
     // The above code should have always made an entry in the map.
     NOTREACHED();
     return PP_MakeUndefined();
   }
 
   // Fix up the references. The host (renderer) just sent us a ref. The
   // renderer has addrefed the var in its tracker for us since it's returning
   // it.
   PluginVarInfo& info = found->second;
   if (info.ref_count == 0) {
     // We don't have a reference to this already, then we just add it to our
     // tracker and use that one ref.
     info.ref_count = 1;
   } else {
     // We already have a reference to it, that means the renderer now has two
     // references on our behalf. We want to transfer that extra reference to
     // our list. This means we addref in the plugin, and release the extra one
     // in the renderer.
     SendReleaseObjectMsg(info.host_var);
     info.ref_count++;
   }
 
   PP_Var ret;
   ret.type = PP_VARTYPE_OBJECT;
   ret.value.as_id = found->first;
   return ret;
 }
 
-PP_Var PluginVarTracker::TrackObjectWithNoReference(const PP_Var& host_var,
-                                                    Sender* channel) {
+PP_Var PluginVarTracker::TrackObjectWithNoReference(
+    const PP_Var& host_var,
+    PluginDispatcher* dispatcher) {
   DCHECK(host_var.type == PP_VARTYPE_OBJECT);
 
   PluginVarInfoMap::iterator found =
-      FindOrMakePluginVarFromHostVar(host_var, channel);
+      FindOrMakePluginVarFromHostVar(host_var, dispatcher);
   if (found == plugin_var_info_.end()) {
     // The above code should have always made an entry in the map.
     NOTREACHED();
     return PP_MakeUndefined();
   }
 
   found->second.track_with_no_reference_count++;
 
   PP_Var ret;
   ret.type = PP_VARTYPE_OBJECT;
@@ skipping 22 matching lines @@
   if (found == plugin_var_info_.end()) {
     NOTREACHED();
     return PP_MakeUndefined();
   }
   PP_Var ret;
   ret.type = PP_VARTYPE_OBJECT;
   ret.value.as_id = found->second.host_var.host_object_id;
   return ret;
 }
 
-void PluginVarTracker::ReleaseHostObject(Sender* sender,
+PluginDispatcher* PluginVarTracker::DispatcherForPluginObject(
+    const PP_Var& plugin_object) const {
+  DCHECK(plugin_object.type == PP_VARTYPE_OBJECT);
+  PluginVarInfoMap::const_iterator found = plugin_var_info_.find(
+      plugin_object.value.as_id);
+  if (found != plugin_var_info_.end())
+    return found->second.host_var.dispatcher;
+  return NULL;
+}
+
+void PluginVarTracker::ReleaseHostObject(PluginDispatcher* dispatcher,
                                          const PP_Var& host_object) {
   // Convert the host object to a normal var valid in the plugin.
   DCHECK(host_object.type == PP_VARTYPE_OBJECT);
   HostVarToPluginVarMap::iterator found = host_var_to_plugin_var_.find(
-      HostVar(sender, host_object.value.as_id));
+      HostVar(dispatcher, host_object.value.as_id));
   if (found == host_var_to_plugin_var_.end()) {
     NOTREACHED();
     return;
   }
 
   // Now just release the object like normal.
   PP_Var plugin_object;
   plugin_object.type = PP_VARTYPE_OBJECT;
   plugin_object.value.as_id = found->second;
   Release(plugin_object);
@@ skipping 10 matching lines @@
 int PluginVarTracker::GetTrackedWithNoReferenceCountForObject(
     const PP_Var& plugin_object) {
   PluginVarInfoMap::iterator found = plugin_var_info_.find(
       plugin_object.value.as_id);
   if (found == plugin_var_info_.end())
     return -1;
   return found->second.track_with_no_reference_count;
 }
 
 void PluginVarTracker::SendAddRefObjectMsg(const HostVar& host_var) {
-  host_var.channel->Send(new PpapiHostMsg_PPBVar_AddRefObject(
+  host_var.dispatcher->Send(new PpapiHostMsg_PPBVar_AddRefObject(
       INTERFACE_ID_PPB_VAR_DEPRECATED, host_var.host_object_id));
 }
 
 void PluginVarTracker::SendReleaseObjectMsg(const HostVar& host_var) {
-  host_var.channel->Send(new PpapiHostMsg_PPBVar_ReleaseObject(
+  host_var.dispatcher->Send(new PpapiHostMsg_PPBVar_ReleaseObject(
       INTERFACE_ID_PPB_VAR_DEPRECATED, host_var.host_object_id));
 }
 
 PluginVarTracker::PluginVarInfoMap::iterator
 PluginVarTracker::FindOrMakePluginVarFromHostVar(const PP_Var& var,
-                                                 Sender* channel) {
+                                                 PluginDispatcher* dispatcher) {
   DCHECK(var.type == PP_VARTYPE_OBJECT);
-  HostVar host_var(channel, var.value.as_id);
+  HostVar host_var(dispatcher, var.value.as_id);
 
   HostVarToPluginVarMap::iterator found =
       host_var_to_plugin_var_.find(host_var);
   if (found != host_var_to_plugin_var_.end()) {
     PluginVarInfoMap::iterator ret = plugin_var_info_.find(found->second);
     DCHECK(ret != plugin_var_info_.end());
     return ret;  // Already know about this var return the ID.
   }
 
   // Make a new var, adding references to both maps.
@@ skipping 11 matching lines @@
 
   // Object ref counts are all zero, delete from both maps.
   DCHECK(host_var_to_plugin_var_.find(iter->second.host_var) !=
          host_var_to_plugin_var_.end());
   host_var_to_plugin_var_.erase(iter->second.host_var);
   plugin_var_info_.erase(iter);
 }
 
 }  // namesace proxy
 }  // namespace pp