Rename DesktopMediaPickerModel[Impl]->[Native]DesktopMediaList

chrome/browser/media/native_desktop_media_list_unittest.cc

 // Copyright 2013 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 "chrome/browser/media/desktop_media_picker_model.h"
+#include "chrome/browser/media/native_desktop_media_list.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
+#include "chrome/browser/media/desktop_media_list_observer.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "third_party/webrtc/modules/desktop_capture/screen_capturer.h"
 #include "third_party/webrtc/modules/desktop_capture/window_capturer.h"
 
 using testing::_;
 using testing::DoAll;
 
 namespace {
 
-class MockObserver : public DesktopMediaPickerModel::Observer {
+class MockObserver : public DesktopMediaListObserver {
  public:
   MOCK_METHOD1(OnSourceAdded, void(int index));
   MOCK_METHOD1(OnSourceRemoved, void(int index));
   MOCK_METHOD1(OnSourceNameChanged, void(int index));
   MOCK_METHOD1(OnSourceThumbnailChanged, void(int index));
 };
 
 class FakeScreenCapturer : public webrtc::ScreenCapturer {
  public:
   FakeScreenCapturer() {}
@@ skipping 79 matching lines @@
 
   WindowId selected_window_id_;
 
   // Frames to be captured per window.
   std::map<WindowId, int8_t> frame_values_;
   base::Lock frame_values_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeWindowCapturer);
 };
 
-class DesktopMediaPickerModelTest : public testing::Test {
+class DesktopMediaListTest : public testing::Test {
  public:
-  DesktopMediaPickerModelTest()
+  DesktopMediaListTest()
       : window_capturer_(NULL),
         ui_thread_(content::BrowserThread::UI,
                    &message_loop_) {
   }
 
   void CreateWithDefaultCapturers() {
     window_capturer_ = new FakeWindowCapturer();
-    model_.reset(new DesktopMediaPickerModelImpl(
+    model_.reset(new NativeDesktopMediaList(
         scoped_ptr<webrtc::ScreenCapturer>(new FakeScreenCapturer()),
         scoped_ptr<webrtc::WindowCapturer>(window_capturer_)));
 
     // Set update period to reduce the time it takes to run tests.
     model_->SetUpdatePeriod(base::TimeDelta::FromMilliseconds(0));
   }
 
  protected:
   // Must be listed before |model_|, so it's destroyed last.
   MockObserver observer_;
 
   // Owned by |model_|;
   FakeWindowCapturer* window_capturer_;
 
-  scoped_ptr<DesktopMediaPickerModelImpl> model_;
+  scoped_ptr<NativeDesktopMediaList> model_;
 
   base::MessageLoop message_loop_;
   content::TestBrowserThread ui_thread_;
 
-  DISALLOW_COPY_AND_ASSIGN(DesktopMediaPickerModelTest);
+  DISALLOW_COPY_AND_ASSIGN(DesktopMediaListTest);
 };
 
 ACTION_P2(CheckListSize, model, expected_list_size) {
-  EXPECT_EQ(expected_list_size, model->source_count());
+  EXPECT_EQ(expected_list_size, model->GetSourceCount());
 }
 
 ACTION_P(QuitMessageLoop, message_loop) {
   message_loop->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
 }
 
-TEST_F(DesktopMediaPickerModelTest, InitialSourceList) {
+TEST_F(DesktopMediaListTest, InitialSourceList) {
   CreateWithDefaultCapturers();
 
   webrtc::WindowCapturer::WindowList list;
   webrtc::WindowCapturer::Window window;
   window.id = 0;
   window.title = "Test window";
   list.push_back(window);
   window_capturer_->SetWindowList(list);
 
   {
     testing::InSequence dummy;
     EXPECT_CALL(observer_, OnSourceAdded(0))
       .WillOnce(CheckListSize(model_.get(), 1));
     EXPECT_CALL(observer_, OnSourceAdded(1))
       .WillOnce(CheckListSize(model_.get(), 2));
     EXPECT_CALL(observer_, OnSourceThumbnailChanged(0));
     EXPECT_CALL(observer_, OnSourceThumbnailChanged(1))
       .WillOnce(QuitMessageLoop(&message_loop_));
   }
   model_->StartUpdating(&observer_);
 
   message_loop_.Run();
 
-  EXPECT_EQ(model_->source(0).id.type, content::DesktopMediaID::TYPE_SCREEN);
-  EXPECT_EQ(model_->source(0).id.id, 0);
-  EXPECT_EQ(model_->source(1).id.type, content::DesktopMediaID::TYPE_WINDOW);
-  EXPECT_EQ(model_->source(1).id.id, 0);
-  EXPECT_EQ(model_->source(1).name, UTF8ToUTF16(window.title));
+  EXPECT_EQ(model_->GetSource(0).id.type, content::DesktopMediaID::TYPE_SCREEN);
+  EXPECT_EQ(model_->GetSource(0).id.id, 0);
+  EXPECT_EQ(model_->GetSource(1).id.type, content::DesktopMediaID::TYPE_WINDOW);
+  EXPECT_EQ(model_->GetSource(1).id.id, 0);
+  EXPECT_EQ(model_->GetSource(1).name, UTF8ToUTF16(window.title));
 }
 
 // Verifies that the window specified with SetViewDialogWindowId() is filtered
 // from the results.
-TEST_F(DesktopMediaPickerModelTest, Filtering) {
+TEST_F(DesktopMediaListTest, Filtering) {
   CreateWithDefaultCapturers();
 
   webrtc::WindowCapturer::WindowList list;
   webrtc::WindowCapturer::Window window;
 
   window.id = 0;
   window.title = "Test window";
   list.push_back(window);
 
   window.id = 1;
@@ skipping 10 matching lines @@
     EXPECT_CALL(observer_, OnSourceThumbnailChanged(0));
     EXPECT_CALL(observer_, OnSourceThumbnailChanged(1))
       .WillOnce(QuitMessageLoop(&message_loop_));
   }
 
   model_->SetViewDialogWindowId(0);
 
   model_->StartUpdating(&observer_);
   message_loop_.Run();
 
-  EXPECT_EQ(model_->source(0).id.type, content::DesktopMediaID::TYPE_SCREEN);
-  EXPECT_EQ(model_->source(0).id.id, 0);
-  EXPECT_EQ(model_->source(1).id.type, content::DesktopMediaID::TYPE_WINDOW);
-  EXPECT_EQ(model_->source(1).id.id, 1);
-  EXPECT_EQ(model_->source(1).name, UTF8ToUTF16(window.title));
+  EXPECT_EQ(model_->GetSource(0).id.type, content::DesktopMediaID::TYPE_SCREEN);
+  EXPECT_EQ(model_->GetSource(0).id.id, 0);
+  EXPECT_EQ(model_->GetSource(1).id.type, content::DesktopMediaID::TYPE_WINDOW);
+  EXPECT_EQ(model_->GetSource(1).id.id, 1);
+  EXPECT_EQ(model_->GetSource(1).name, UTF8ToUTF16(window.title));
 }
 
-TEST_F(DesktopMediaPickerModelTest, WindowsOnly) {
+TEST_F(DesktopMediaListTest, WindowsOnly) {
   window_capturer_ = new FakeWindowCapturer();
-  model_.reset(new DesktopMediaPickerModelImpl(
+  model_.reset(new NativeDesktopMediaList(
       scoped_ptr<webrtc::ScreenCapturer>(),
       scoped_ptr<webrtc::WindowCapturer>(window_capturer_)));
 
   webrtc::WindowCapturer::WindowList list;
   webrtc::WindowCapturer::Window window;
   window.id = 0;
   window.title = "Test window";
   list.push_back(window);
   window_capturer_->SetWindowList(list);
 
   {
     testing::InSequence dummy;
     EXPECT_CALL(observer_, OnSourceAdded(0))
       .WillOnce(CheckListSize(model_.get(), 1));
     EXPECT_CALL(observer_, OnSourceThumbnailChanged(0))
       .WillOnce(QuitMessageLoop(&message_loop_));
   }
   model_->StartUpdating(&observer_);
 
   message_loop_.Run();
 
-  EXPECT_EQ(model_->source(0).id.type, content::DesktopMediaID::TYPE_WINDOW);
+  EXPECT_EQ(model_->GetSource(0).id.type, content::DesktopMediaID::TYPE_WINDOW);
 }
 
-TEST_F(DesktopMediaPickerModelTest, ScreenOnly) {
-  model_.reset(new DesktopMediaPickerModelImpl(
+TEST_F(DesktopMediaListTest, ScreenOnly) {
+  model_.reset(new NativeDesktopMediaList(
       scoped_ptr<webrtc::ScreenCapturer>(new FakeScreenCapturer),
       scoped_ptr<webrtc::WindowCapturer>()));
 
   {
     testing::InSequence dummy;
     EXPECT_CALL(observer_, OnSourceAdded(0))
       .WillOnce(CheckListSize(model_.get(), 1));
     EXPECT_CALL(observer_, OnSourceThumbnailChanged(0))
       .WillOnce(QuitMessageLoop(&message_loop_));
   }
   model_->StartUpdating(&observer_);
 
   message_loop_.Run();
 
-  EXPECT_EQ(model_->source(0).id.type, content::DesktopMediaID::TYPE_SCREEN);
+  EXPECT_EQ(model_->GetSource(0).id.type, content::DesktopMediaID::TYPE_SCREEN);
 }
 
-TEST_F(DesktopMediaPickerModelTest, AddWindow) {
+TEST_F(DesktopMediaListTest, AddWindow) {
   CreateWithDefaultCapturers();
 
   webrtc::WindowCapturer::WindowList list;
   webrtc::WindowCapturer::Window window;
   window.id = 1;
   window.title = "Test window 1";
   list.push_back(window);
   window_capturer_->SetWindowList(list);
 
   {
@@ skipping 16 matching lines @@
     .WillOnce(DoAll(CheckListSize(model_.get(), 3),
                     QuitMessageLoop(&message_loop_)));
 
   window.id = 0;
   window.title = "Test window 0";
   list.push_back(window);
   window_capturer_->SetWindowList(list);
 
   message_loop_.Run();
 
-  EXPECT_EQ(model_->source(1).id.type, content::DesktopMediaID::TYPE_WINDOW);
-  EXPECT_EQ(model_->source(1).id.id, 0);
+  EXPECT_EQ(model_->GetSource(1).id.type, content::DesktopMediaID::TYPE_WINDOW);
+  EXPECT_EQ(model_->GetSource(1).id.id, 0);
 }
 
-TEST_F(DesktopMediaPickerModelTest, RemoveWindow) {
+TEST_F(DesktopMediaListTest, RemoveWindow) {
   CreateWithDefaultCapturers();
 
   webrtc::WindowCapturer::WindowList list;
   webrtc::WindowCapturer::Window window;
   window.id = 0;
   window.title = "Test window 0";
   list.push_back(window);
   window.id = 1;
   window.title = "Test window 1";
   list.push_back(window);
@@ skipping 21 matching lines @@
   EXPECT_CALL(observer_, OnSourceRemoved(1))
     .WillOnce(DoAll(CheckListSize(model_.get(), 2),
                     QuitMessageLoop(&message_loop_)));
 
   list.erase(list.begin());
   window_capturer_->SetWindowList(list);
 
   message_loop_.Run();
 }
 
-TEST_F(DesktopMediaPickerModelTest, UpdateTitle) {
+TEST_F(DesktopMediaListTest, UpdateTitle) {
   CreateWithDefaultCapturers();
 
   webrtc::WindowCapturer::WindowList list;
   webrtc::WindowCapturer::Window window;
   window.id = 0;
   window.title = "Test window";
   list.push_back(window);
   window_capturer_->SetWindowList(list);
 
   {
@@ skipping 15 matching lines @@
   EXPECT_CALL(observer_, OnSourceNameChanged(1))
     .WillOnce(QuitMessageLoop(&message_loop_));
 
   const std::string kTestTitle = "New Title";
 
   list[0].title = kTestTitle;
   window_capturer_->SetWindowList(list);
 
   message_loop_.Run();
 
-  EXPECT_EQ(model_->source(1).name, base::UTF8ToUTF16(kTestTitle));
+  EXPECT_EQ(model_->GetSource(1).name, base::UTF8ToUTF16(kTestTitle));
 }
 
-TEST_F(DesktopMediaPickerModelTest, UpdateThumbnail) {
+TEST_F(DesktopMediaListTest, UpdateThumbnail) {
   CreateWithDefaultCapturers();
 
   webrtc::WindowCapturer::WindowList list;
   webrtc::WindowCapturer::Window window;
   window.id = 0;
   window.title = "Test window 1";
   list.push_back(window);
   window.id = 1;
   window.title = "Test window 2";
   list.push_back(window);
@@ skipping 21 matching lines @@
   EXPECT_CALL(observer_, OnSourceThumbnailChanged(1))
     .WillOnce(QuitMessageLoop(&message_loop_));
 
   // Update frame for the window and verify that we get notification about it.
   window_capturer_->SetNextFrameValue(0, 1);
 
   message_loop_.Run();
 }
 
 }  // namespace