Add a new globals object for PPAPI tracking information.

ppapi/proxy/plugin_globals.h

Index: ppapi/proxy/plugin_globals.h
diff --git a/ppapi/proxy/plugin_globals.h b/ppapi/proxy/plugin_globals.h
new file mode 100644
index 0000000000000000000000000000000000000000..141b90456dd866305dbe042f326aec78c65eaabf
--- /dev/null
+++ b/ppapi/proxy/plugin_globals.h
@@ -0,0 +1,50 @@
+// 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.
+
+#ifndef PPAPI_PROXY_PLUGIN_GLOBALS_H_
+#define PPAPI_PROXY_PLUGIN_GLOBALS_H_
+
+#include "base/compiler_specific.h"
+#include "ppapi/proxy/plugin_resource_tracker.h"
+#include "ppapi/proxy/plugin_var_tracker.h"
+#include "ppapi/shared_impl/ppapi_globals.h"
+
+namespace ppapi {
+namespace proxy {
+
+class PluginGlobals : public PpapiGlobals {
+ public:
+  PluginGlobals();
+  virtual ~PluginGlobals();
+
+  // Getter for the global singleton. Generally, you should use
+  // PpapiGlobals::Get() when possible. Use this only when you need some
+  // plugin-specific functionality.
+  inline static PluginGlobals* Get() { return plugin_globals_; }
+
+  // PpapiGlobals implementation.
+  virtual ResourceTracker* GetResourceTracker() OVERRIDE;

[yzshen1, 2011/10/18 20:09:57]

[optional]
It seems good to me to make
PluginGlobals::Get()->GetResourceTracker() directly return
PluginResourceTracker*. If the user needs ResourceTracker*, he/she could use
PpapiGlobals::Get()->GetResourceTracker().

I think static binding could be used to do this.

[brettw, 2011/10/18 20:43:54]

This function is an implementation of the pure virtual function on the
PpapiGlobals object. So we'll need it here no matter what (I did consider
passing these into the PpapiGlobals constructor which would save the virtual
function calls, but that seemed more complicated... we can do that if it turns
out this is showing up on perf).
I don't think C++ does binding based on return type, so I'm not sure how this
would work. Maybe I'm missing something, though.

[yzshen1, 2011/10/18 20:53:35]

[optional, not intended to block your check in.]
I am thinking about something like this: :)

class PpapiGlobals {
  PpapiGlobals(ResourceTracker* resource_tracker)
    : resource_tracker_(resource_tracker) {}
  ...
  // Not virtual
  ResourceTracker* GetResourceTracker() {
    return resource_tracker_;
  }
};

class PluginGlobals {
  PluginGlobals()
    : PpapiGlobals(&plugin_resource_tracker_) {}
  ...
  // Not virtual
  PluginResourceTracker* GetResourceTracker() {
    return &plugin_resource_tracker_;
  }
  ...
  PluginResourceTracker plugin_resource_tracker_;
};

+  virtual VarTracker* GetVarTracker() OVERRIDE;
+
+  // Getters for the plugin-specific versions.
+  PluginResourceTracker* plugin_resource_tracker() {
+    return &plugin_resource_tracker_;
+  }
+  PluginVarTracker* plugin_var_tracker() {
+    return &plugin_var_tracker_;
+  }
+
+ private:
+  static PluginGlobals* plugin_globals_;
+
+  PluginResourceTracker plugin_resource_tracker_;
+  PluginVarTracker plugin_var_tracker_;
+
+  DISALLOW_COPY_AND_ASSIGN(PluginGlobals);
+};
+
+}  // namespace proxy
+}  // namespace ppapi
+
+#endif   // PPAPI_PROXY_PLUGIN_GLOBALS_H_