Various fixes to make ppapi_unittests pass again.

ppapi/proxy/ppapi_proxy_test.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.
 
 #include <map>
 #include <string>
 
 #include "base/message_loop.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 16 matching lines @@
 // directly. Instead, use the PluginProxyTest, HostProxyTest, or TwoWayTest.
 class ProxyTestHarnessBase {
  public:
   ProxyTestHarnessBase();
   virtual ~ProxyTestHarnessBase();
 
   PP_Module pp_module() const { return pp_module_; }
   PP_Instance pp_instance() const { return pp_instance_; }
   ResourceMessageTestSink& sink() { return sink_; }
 
+  // This should lazily initialize the globals so they are constructed on
+  // the thread of use.
   virtual PpapiGlobals* GetGlobals() = 0;
   // Returns either the plugin or host dispatcher, depending on the test.
   virtual Dispatcher* GetDispatcher() = 0;
 
   // Set up the harness using an IPC::TestSink to capture messages.
   virtual void SetUpHarness() = 0;
 
   // Set up the harness using a real IPC channel.
   virtual void SetUpHarnessWithChannel(const IPC::ChannelHandle& channel_handle,
                                        base::MessageLoopProxy* ipc_message_loop,
@@ skipping 29 matching lines @@
 };
 
 // Test harness for the plugin side of the proxy.
 class PluginProxyTestHarness : public ProxyTestHarnessBase {
  public:
   PluginProxyTestHarness();
   virtual ~PluginProxyTestHarness();
 
   PluginDispatcher* plugin_dispatcher() { return plugin_dispatcher_.get(); }
   PluginResourceTracker& resource_tracker() {
-    return *plugin_globals_.plugin_resource_tracker();
+    return *plugin_globals_->plugin_resource_tracker();
   }
   PluginVarTracker& var_tracker() {
-    return *plugin_globals_.plugin_var_tracker();
+    return *plugin_globals_->plugin_var_tracker();
   }
 
   // ProxyTestHarnessBase implementation.
-  virtual PpapiGlobals* GetGlobals() { return &plugin_globals_; }
+  virtual PpapiGlobals* GetGlobals();
   virtual Dispatcher* GetDispatcher();
   virtual void SetUpHarness();
   virtual void SetUpHarnessWithChannel(const IPC::ChannelHandle& channel_handle,
                                        base::MessageLoopProxy* ipc_message_loop,
                                        base::WaitableEvent* shutdown_event,
                                        bool is_client);
   virtual void TearDownHarness();
 
   class PluginDelegateMock : public PluginDispatcher::PluginDelegate,
                              public PluginProxyDelegate {
    public:
     PluginDelegateMock() : ipc_message_loop_(NULL), shutdown_event_() {}
     virtual ~PluginDelegateMock() {}
 
     void Init(base::MessageLoopProxy* ipc_message_loop,
               base::WaitableEvent* shutdown_event) {
       ipc_message_loop_ = ipc_message_loop;
       shutdown_event_ = shutdown_event;
     }
 
+    void set_browser_sender(IPC::Sender* browser_sender) {
+      browser_sender_ = browser_sender;
+    }
+
     // ProxyChannel::Delegate implementation.
     virtual base::MessageLoopProxy* GetIPCMessageLoop() OVERRIDE;
     virtual base::WaitableEvent* GetShutdownEvent() OVERRIDE;
     virtual IPC::PlatformFileForTransit ShareHandleWithRemote(
         base::PlatformFile handle,
         const IPC::SyncChannel& /* channel */,
         bool should_close_source) OVERRIDE;
 
     // PluginDispatcher::PluginDelegate implementation.
     virtual std::set<PP_Instance>* GetGloballySeenInstanceIDSet() OVERRIDE;
     virtual uint32 Register(PluginDispatcher* plugin_dispatcher) OVERRIDE;
     virtual void Unregister(uint32 plugin_dispatcher_id) OVERRIDE;
 
     // PluginPepperDelegate implementation.

[dmichael (off chromium), 2012/09/17 15:27:29]

Can you change this to say PluginProxyDelegate, since you're here?

[raymes, 2012/09/18 21:29:15]

Done.

     virtual bool SendToBrowser(IPC::Message* msg) OVERRIDE;
     virtual IPC::Sender* GetBrowserSender() OVERRIDE;
     virtual std::string GetUILanguage() OVERRIDE;
     virtual void PreCacheFont(const void* logfontw) OVERRIDE;
     virtual void SetActiveURL(const std::string& url) OVERRIDE;
 
    private:
     base::MessageLoopProxy* ipc_message_loop_;  // Weak
     base::WaitableEvent* shutdown_event_;  // Weak
     std::set<PP_Instance> instance_id_set_;
+    IPC::Sender* browser_sender_;
 
     DISALLOW_COPY_AND_ASSIGN(PluginDelegateMock);
   };
 
  private:
-  PluginGlobals plugin_globals_;
+  scoped_ptr<PluginGlobals> plugin_globals_;
 
   scoped_ptr<PluginDispatcher> plugin_dispatcher_;
   PluginDelegateMock plugin_delegate_mock_;
 };
 
 class PluginProxyTest : public PluginProxyTestHarness, public testing::Test {
  public:
   PluginProxyTest();
   virtual ~PluginProxyTest();
 
   // testing::Test implementation.
   virtual void SetUp();
   virtual void TearDown();
  private:
   MessageLoop message_loop_;
 };
 
 class HostProxyTestHarness : public ProxyTestHarnessBase {
  public:
   HostProxyTestHarness();
   virtual ~HostProxyTestHarness();
 
   HostDispatcher* host_dispatcher() { return host_dispatcher_.get(); }
   ResourceTracker& resource_tracker() {
-    return *host_globals_.GetResourceTracker();
+    return *host_globals_->GetResourceTracker();
   }
   VarTracker& var_tracker() {
-    return *host_globals_.GetVarTracker();
+    return *host_globals_->GetVarTracker();
   }
 
   // ProxyTestBase implementation.
-  virtual PpapiGlobals* GetGlobals() { return &host_globals_; }
+  virtual PpapiGlobals* GetGlobals();
   virtual Dispatcher* GetDispatcher();
   virtual void SetUpHarness();
   virtual void SetUpHarnessWithChannel(const IPC::ChannelHandle& channel_handle,
                                        base::MessageLoopProxy* ipc_message_loop,
                                        base::WaitableEvent* shutdown_event,
                                        bool is_client);
   virtual void TearDownHarness();
 
   class DelegateMock : public ProxyChannel::Delegate {
    public:
@@ skipping 18 matching lines @@
    private:
     base::MessageLoopProxy* ipc_message_loop_;  // Weak
     base::WaitableEvent* shutdown_event_;  // Weak
 
     DISALLOW_COPY_AND_ASSIGN(DelegateMock);
   };
 
  private:
   class MockSyncMessageStatusReceiver;
 
-  ppapi::TestGlobals host_globals_;
+  scoped_ptr<ppapi::TestGlobals> host_globals_;
   scoped_ptr<HostDispatcher> host_dispatcher_;
   DelegateMock delegate_mock_;
 
   scoped_ptr<MockSyncMessageStatusReceiver> status_receiver_;
 };
 
 class HostProxyTest : public HostProxyTestHarness, public testing::Test {
  public:
   HostProxyTest();
   virtual ~HostProxyTest();
@@ skipping 18 matching lines @@
   HostProxyTestHarness& host() { return host_; }
   PluginProxyTestHarness& plugin() { return plugin_; }
   PP_Module pp_module() const { return host_.pp_module(); }
   PP_Instance pp_instance() const { return host_.pp_instance(); }
   TwoWayTestMode test_mode() { return test_mode_; }
 
   // testing::Test implementation.
   virtual void SetUp();
   virtual void TearDown();
 
+ protected:
+  // Post a task to the thread where the remote harness lives. This
+  // is typically used to test the state of the var tracker on the plugin
+  // thread. This runs the task synchronously for convenience.
+  void PostTaskOnRemoteHarness(const base::Closure& task);
+
  private:
   TwoWayTestMode test_mode_;
   HostProxyTestHarness host_;
   PluginProxyTestHarness plugin_;
   // In order to use sync IPC, we need to have an IO thread.
   base::Thread io_thread_;
   // The plugin side of the proxy runs on its own thread.
   base::Thread plugin_thread_;
   // The message loop for the main (host) thread.
   MessageLoop message_loop_;
@@ skipping 15 matching lines @@
 //   EXPECT_VAR_IS_STRING("foo", my_var);
 #define EXPECT_VAR_IS_STRING(str, var) { \
   StringVar* sv = StringVar::FromPPVar(var); \
   EXPECT_TRUE(sv); \
   if (sv) \
     EXPECT_EQ(str, sv->value()); \
 }
 
 }  // namespace proxy
 }  // namespace ppapi