Minor cleanup to remove the static thread-safe methods on BrowserMainLoop. Initially I thought this…

content/browser/renderer_host/media/media_stream_dispatcher_host_unittest.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 <string>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/media/media_stream_dispatcher_host.h"
@@ skipping 23 matching lines @@
 const int kRenderId = 6;
 const int kPageRequestId = 7;
 
 namespace content {
 
 class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost,
                                       public TestContentBrowserClient {
  public:
   MockMediaStreamDispatcherHost(base::MessageLoop* message_loop,
                                 MediaStreamManager* manager)
-      : MediaStreamDispatcherHost(kProcessId),
-        message_loop_(message_loop),
-        manager_(manager) {}
+      : MediaStreamDispatcherHost(kProcessId, manager),
+        message_loop_(message_loop) {}
 
   // A list of mock methods.
   MOCK_METHOD4(OnStreamGenerated,
                void(int routing_id, int request_id, int audio_array_size,
                     int video_array_size));
   MOCK_METHOD2(OnStreamGenerationFailed, void(int routing_id, int request_id));
 
   // Accessor to private functions.
   void OnGenerateStream(int page_request_id, const StreamOptions& components) {
     MediaStreamDispatcherHost::OnGenerateStream(kRenderId,
@@ skipping 31 matching lines @@
       IPC_MESSAGE_HANDLER(MediaStreamMsg_StreamGenerationFailed,
                           OnStreamGenerationFailed)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     EXPECT_TRUE(handled);
 
     delete message;
     return true;
   }
 
-  // Use our own MediaStreamManager.
-  virtual MediaStreamManager* GetManager() OVERRIDE {
-    return manager_;
-  }
-
   // These handler methods do minimal things and delegate to the mock methods.
   void OnStreamGenerated(
       const IPC::Message& msg,
       int request_id,
       std::string label,
       StreamDeviceInfoArray audio_device_list,
       StreamDeviceInfoArray video_device_list) {
     OnStreamGenerated(msg.routing_id(), request_id, audio_device_list.size(),
         video_device_list.size());
     // Notify that the event have occured.
     message_loop_->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
     label_ = label;
     audio_devices_ = audio_device_list;
     video_devices_ = video_device_list;
   }
 
   void OnStreamGenerationFailed(const IPC::Message& msg, int request_id) {
     OnStreamGenerationFailed(msg.routing_id(), request_id);
     message_loop_->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
     label_= "";
   }
 
   base::MessageLoop* message_loop_;
-  MediaStreamManager* manager_;
 };
 
 class MockMediaStreamUIProxy : public FakeMediaStreamUIProxy {
  public:
   MOCK_METHOD1(OnStarted, void(const base::Closure& stop));
 };
 
 class MediaStreamDispatcherHostTest : public testing::Test {
  public:
   MediaStreamDispatcherHostTest() : old_browser_client_(NULL) {}
@@ skipping 218 matching lines @@
   EXPECT_EQ(host_->NumberOfStreams(), 1u);
 
   ASSERT_FALSE(close_callback.is_null());
   close_callback.Run();
   message_loop_->RunUntilIdle();
 
   EXPECT_EQ(host_->NumberOfStreams(), 0u);
 }
 
 };  // namespace content