PPAPI: Remove threading options; it's always on

ppapi/shared_impl/var_tracker.h

 // Copyright (c) 2012 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_SHARED_IMPL_VAR_TRACKER_H_
 #define PPAPI_SHARED_IMPL_VAR_TRACKER_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/shared_memory.h"
-#include "base/threading/non_thread_safe.h"
+#include "base/threading/thread_checker.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_module.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/shared_impl/host_resource.h"
 #include "ppapi/shared_impl/ppapi_shared_export.h"
 
 namespace ppapi {
 
 class ArrayBufferVar;
 class Var;
 
 // Tracks non-POD (refcounted) var objects held by a plugin.
 //
 // The tricky part is the concept of a "tracked object". These are only
 // necessary in the plugin side of the proxy when running out of process. A
 // tracked object is one that the plugin is aware of, but doesn't hold a
 // reference to. This will happen when the plugin is passed an object as an
 // argument from the host (renderer) as an input argument to a sync function,
 // but where ownership is not passed.
 //
 // This class maintains the "track_with_no_reference_count" but doesn't do
 // anything with it other than call virtual functions. The interesting parts
 // are added by the PluginObjectVar derived from this class.
-class PPAPI_SHARED_EXPORT VarTracker
-#ifdef ENABLE_PEPPER_THREADING
-    : NON_EXPORTED_BASE(public base::NonThreadSafeDoNothing) {
-#else
-    // TODO(dmichael): Remove the thread checking when calls are allowed off the
-    // main thread (crbug.com/92909).
-    : NON_EXPORTED_BASE(public base::NonThreadSafe) {
-#endif
+class PPAPI_SHARED_EXPORT VarTracker {
  public:
-  VarTracker();
+  // A SINGLE_THREADED VarTracker will use a thread-checker to make sure it's
+  // always invoked on the same thread on which it was constructed. A
+  // THREAD_SAFE VarTracker will check that the ProxyLock is held. See
+  // CheckThreadingPreconditions() for more details.
+  enum ThreadMode { SINGLE_THREADED, THREAD_SAFE };
+  explicit VarTracker(ThreadMode thread_mode);
   virtual ~VarTracker();
 
   // Called by the Var object to add a new var to the tracker.
   int32 AddVar(Var* var);
 
   // Looks up a given var and returns a reference to the Var if it exists.
   // Returns NULL if the var type is not an object we track (POD) or is
   // invalid.
   Var* GetVar(int32 var_id) const;
   Var* GetVar(const PP_Var& var) const;
@@ skipping 82 matching lines @@
     int track_with_no_reference_count;
   };
   typedef base::hash_map<int32, VarInfo> VarMap;
 
   // Specifies what should happen with the refcount when calling AddVarInternal.
   enum AddVarRefMode {
     ADD_VAR_TAKE_ONE_REFERENCE,
     ADD_VAR_CREATE_WITH_NO_REFERENCE
   };
 
+  // On the host-side, make sure we are called on the right thread. On the
+  // plugin side, make sure we have the proxy lock.
+  void CheckThreadingPreconditions() const;
+
   // Implementation of AddVar that allows the caller to specify whether the
   // initial refcount of the added object will be 0 or 1.
   //
   // Overridden in the plugin proxy to do additional object tracking.
   virtual int32 AddVarInternal(Var* var, AddVarRefMode mode);
 
   // Convenience functions for doing lookups into the live_vars_ map.
   VarMap::iterator GetLiveVar(int32 id);
   VarMap::iterator GetLiveVar(const PP_Var& var);
   VarMap::const_iterator GetLiveVar(const PP_Var& var) const;
@@ skipping 30 matching lines @@
 
  private:
   // Create and return a new ArrayBufferVar size_in_bytes bytes long. This is
   // implemented by the Host and Plugin tracker separately, so that it can be
   // a real WebKit ArrayBuffer on the host side.
   virtual ArrayBufferVar* CreateArrayBuffer(uint32 size_in_bytes) = 0;
   virtual ArrayBufferVar* CreateShmArrayBuffer(
       uint32 size_in_bytes,
       base::SharedMemoryHandle handle) = 0;
 
+  // On the host side, we want to check that we are only called on the main
+  // thread. This is to protect us from accidentally using the tracker from
+  // other threads (especially the IO thread). On the plugin side, the tracker
+  // is protected by the proxy lock and is thread-safe, so this will be NULL.
+  scoped_ptr<base::ThreadChecker> thread_checker_;
+
   DISALLOW_COPY_AND_ASSIGN(VarTracker);
 };
 
 }  // namespace ppapi
 
 #endif  // PPAPI_SHARED_IMPL_VAR_TRACKER_H_