PPAPI: Make tests that disable the proxy lock re-enable it

ppapi/proxy/ppapi_proxy_test.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/ppapi_proxy_test.h"
 
 #include <sstream>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/observer_list.h"
 #include "base/process/process_handle.h"
 #include "base/run_loop.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ipc/message_filter.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/private/ppb_proxy_private.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_message_loop_proxy.h"
-#include "ppapi/shared_impl/proxy_lock.h"
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 // HostDispatcher requires a PPB_Proxy_Private, so we always provide a fallback
 // do-nothing implementation.
 void PluginCrashed(PP_Module module) {
   NOTREACHED();
 };
@@ skipping 190 matching lines @@
 
     resource_tracker().DidDeleteInstance(pp_instance());
   }
   plugin_globals_.reset();
 }
 
 void PluginProxyTestHarness::CreatePluginGlobals() {
   if (globals_config_ == PER_THREAD_GLOBALS) {
     plugin_globals_.reset(new PluginGlobals(PpapiGlobals::PerThreadForTest()));
     PpapiGlobals::SetPpapiGlobalsOnThreadForTest(GetGlobals());
-    // Enable locking in case some other unit test ran before us and disabled
-    // locking.
-    ProxyLock::EnableLockingOnThreadForTest();
   } else {
     plugin_globals_.reset(new PluginGlobals());
-    ProxyLock::EnableLockingOnThreadForTest();
   }
 }
 
 base::MessageLoopProxy*
 PluginProxyTestHarness::PluginDelegateMock::GetIPCMessageLoop() {
   return ipc_message_loop_;
 }
 
 base::WaitableEvent*
 PluginProxyTestHarness::PluginDelegateMock::GetShutdownEvent() {
@@ skipping 209 matching lines @@
   HostDispatcher::SetForInstance(pp_instance(), host_dispatcher_.get());
 }
 
 void HostProxyTestHarness::TearDownHarness() {
   HostDispatcher::RemoveForInstance(pp_instance());
   host_dispatcher_.reset();
   host_globals_.reset();
 }
 
 void HostProxyTestHarness::CreateHostGlobals() {
+  disable_locking_.reset(new ProxyLock::LockingDisablerForTest);
   if (globals_config_ == PER_THREAD_GLOBALS) {
     host_globals_.reset(new TestGlobals(PpapiGlobals::PerThreadForTest()));
     PpapiGlobals::SetPpapiGlobalsOnThreadForTest(GetGlobals());
-    // The host side of the proxy does not lock.
-    ProxyLock::DisableLockingOnThreadForTest();
   } else {
-    ProxyLock::DisableLockingOnThreadForTest();
     host_globals_.reset(new TestGlobals());
   }
 }
 
 base::MessageLoopProxy*
 HostProxyTestHarness::DelegateMock::GetIPCMessageLoop() {
   return ipc_message_loop_;
 }
 
 base::WaitableEvent* HostProxyTestHarness::DelegateMock::GetShutdownEvent() {
@@ skipping 98 matching lines @@
   plugin_thread_.message_loop_proxy()->PostTask(FROM_HERE,
       base::Bind(&RunTaskOnRemoteHarness,
                  task,
                  &task_complete));
   task_complete.Wait();
 }
 
 
 }  // namespace proxy
 }  // namespace ppapi