PPAPI: Remove threading options; it's always on

ppapi/proxy/plugin_globals.cc

 // 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.
 
 #include "ppapi/proxy/plugin_globals.h"
 
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sender.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_proxy_delegate.h"
@@ skipping 31 matching lines @@
   IPC::Sender* underlying_sender_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserSender);
 };
 
 PluginGlobals* PluginGlobals::plugin_globals_ = NULL;
 
 PluginGlobals::PluginGlobals()
     : ppapi::PpapiGlobals(),
       plugin_proxy_delegate_(NULL),
-      callback_tracker_(new CallbackTracker),
-      loop_for_main_thread_(
-          new MessageLoopResource(MessageLoopResource::ForMainThread())) {
-#if defined(ENABLE_PEPPER_THREADING)
-  enable_threading_ = true;
-#else
-  enable_threading_ = false;
-#endif
-
+      callback_tracker_(new CallbackTracker) {
   DCHECK(!plugin_globals_);
   plugin_globals_ = this;
+
+  // ResourceTracker asserts that we have the lock when we add new resources,
+  // so we lock when creating the MessageLoopResource even though there is no
+  // chance of race conditions.
+  ProxyAutoLock lock;
+  loop_for_main_thread_ =
+      new MessageLoopResource(MessageLoopResource::ForMainThread());
 }
 
 PluginGlobals::PluginGlobals(PerThreadForTest per_thread_for_test)
     : ppapi::PpapiGlobals(per_thread_for_test),
       plugin_proxy_delegate_(NULL),
       callback_tracker_(new CallbackTracker) {
-#if defined(ENABLE_PEPPER_THREADING)
-  enable_threading_ = true;
-#else
-  enable_threading_ = false;
-#endif
   DCHECK(!plugin_globals_);
 }
 
 PluginGlobals::~PluginGlobals() {
   DCHECK(plugin_globals_ == this || !plugin_globals_);
-  // Release the main-thread message loop. We should have the last reference
-  // count, so this will delete the MessageLoop resource. We do this before
-  // we clear plugin_globals_, because the Resource destructor tries to access
-  // this PluginGlobals.
-  DCHECK(!loop_for_main_thread_ || loop_for_main_thread_->HasOneRef());
-  loop_for_main_thread_ = NULL;
-
+  {
+    ProxyAutoLock lock;
+    // Release the main-thread message loop. We should have the last reference
+    // count, so this will delete the MessageLoop resource. We do this before
+    // we clear plugin_globals_, because the Resource destructor tries to access
+    // this PluginGlobals.
+    DCHECK(!loop_for_main_thread_ || loop_for_main_thread_->HasOneRef());
+    loop_for_main_thread_ = NULL;
+  }
   plugin_globals_ = NULL;
 }
 
 ResourceTracker* PluginGlobals::GetResourceTracker() {
   return &plugin_resource_tracker_;
 }
 
 VarTracker* PluginGlobals::GetVarTracker() {
   return &plugin_var_tracker_;
 }
@@ skipping 28 matching lines @@
 std::string PluginGlobals::GetCmdLine() {
   return command_line_;
 }
 
 void PluginGlobals::PreCacheFontForFlash(const void* logfontw) {
   ProxyAutoUnlock unlock;
   plugin_proxy_delegate_->PreCacheFont(logfontw);
 }
 
 base::Lock* PluginGlobals::GetProxyLock() {
-  if (enable_threading_)
-    return &proxy_lock_;
-  return NULL;
+  return &proxy_lock_;
 }
 
 void PluginGlobals::LogWithSource(PP_Instance instance,
                                   PP_LogLevel level,
                                   const std::string& source,
                                   const std::string& value) {
   const std::string& fixed_up_source = source.empty() ? plugin_name_ : source;
   PluginDispatcher::LogWithSource(instance, level, fixed_up_source, value);
 }
 
@@ skipping 31 matching lines @@
 MessageLoopResource* PluginGlobals::loop_for_main_thread() {
   return loop_for_main_thread_.get();
 }
 
 bool PluginGlobals::IsPluginGlobals() const {
   return true;
 }
 
 }  // namespace proxy
 }  // namespace ppapi