Hide ContentClient getters from embedders so that they they don't reuse content's embedder API. The…

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 110 matching lines @@
     message_loop_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
     label_= "";
   }
 
   MessageLoop* message_loop_;
   MediaStreamManager* manager_;
 };
 
 class MediaStreamDispatcherHostTest : public testing::Test {
  public:
-  MediaStreamDispatcherHostTest() : old_client_(NULL),
-                                    old_browser_client_(NULL) {}
+  MediaStreamDispatcherHostTest() : old_browser_client_(NULL) {}
   virtual ~MediaStreamDispatcherHostTest() {}
 
   void WaitForResult() {
     message_loop_->Run();
   }
 
  protected:
   virtual void SetUp() OVERRIDE {
     // MediaStreamManager must be created and called on IO thread.
     message_loop_.reset(new MessageLoop(MessageLoop::TYPE_IO));
     io_thread_.reset(new BrowserThreadImpl(BrowserThread::IO,
                                            message_loop_.get()));
 
     // Create our own media observer.
     media_observer_.reset(new MockMediaObserver());
 
     // Create our own MediaStreamManager.
     audio_manager_.reset(media::AudioManager::Create());
     media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
     // Make sure we use fake devices to avoid long delays.
     media_stream_manager_->UseFakeDevice();
 
     host_ = new MockMediaStreamDispatcherHost(message_loop_.get(),
                                               media_stream_manager_.get());
 
     // Use the fake content client and browser.
-    old_client_ = GetContentClient();
-    old_browser_client_ = GetContentClient()->browser();
     content_client_.reset(new TestContentClient);
     SetContentClient(content_client_.get());
-    content_client_->set_browser_for_testing(host_);
+    old_browser_client_ = SetBrowserClientForTesting(host_);
   }
 
   virtual void TearDown() OVERRIDE {
     message_loop_->RunUntilIdle();
 
     // Recover the old browser client and content client.
-    GetContentClient()->set_browser_for_testing(old_browser_client_);
-    SetContentClient(old_client_);
+    SetBrowserClientForTesting(old_browser_client_);
     content_client_.reset();
 
     // Delete the IO message loop to delete the device thread,
     // AudioInputDeviceManager and VideoCaptureManager.
     message_loop_.reset();
   }
 
   scoped_refptr<MockMediaStreamDispatcherHost> host_;
   scoped_ptr<MessageLoop> message_loop_;
   scoped_ptr<BrowserThreadImpl> io_thread_;
   scoped_ptr<media::AudioManager> audio_manager_;
   scoped_ptr<MediaStreamManager> media_stream_manager_;
-  ContentClient* old_client_;
   ContentBrowserClient* old_browser_client_;
   scoped_ptr<ContentClient> content_client_;
   scoped_ptr<MockMediaObserver> media_observer_;
 };
 
 TEST_F(MediaStreamDispatcherHostTest, GenerateStream) {
   StreamOptions options(MEDIA_NO_SERVICE, MEDIA_DEVICE_VIDEO_CAPTURE);
 
   EXPECT_CALL(*host_, GetMediaObserver())
       .WillRepeatedly(Return(media_observer_.get()));
@@ skipping 168 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