chrome/browser/media/native_desktop_media_list_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/media/native_desktop_media_list.h"
   6
   7 #include "base/location.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/single_thread_task_runner.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "base/synchronization/lock.h"
  12 #include "chrome/browser/media/desktop_media_list_observer.h"
  13 #include "content/public/test/test_browser_thread.h"
  14 #include "testing/gmock/include/gmock/gmock.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
  17 #include "third_party/webrtc/modules/desktop_capture/screen_capturer.h"
  18 #include "third_party/webrtc/modules/desktop_capture/window_capturer.h"
  19
  20 using testing::_;
  21 using testing::DoAll;
  22
  23 namespace {
  24
  25 class MockObserver : public DesktopMediaListObserver {
  26  public:
  27   MOCK_METHOD1(OnSourceAdded, void(int index));
  28   MOCK_METHOD1(OnSourceRemoved, void(int index));
  29   MOCK_METHOD2(OnSourceMoved, void(int old_index, int new_index));
  30   MOCK_METHOD1(OnSourceNameChanged, void(int index));
  31   MOCK_METHOD1(OnSourceThumbnailChanged, void(int index));
  32 };
  33
  34 class FakeScreenCapturer : public webrtc::ScreenCapturer {
  35  public:
  36   FakeScreenCapturer() {}
  37   ~FakeScreenCapturer() override {}
  38
  39   // webrtc::ScreenCapturer implementation.
  40   void Start(Callback* callback) override { callback_ = callback; }
  41
  42   void Capture(const webrtc::DesktopRegion& region) override {
  43     DCHECK(callback_);
  44     webrtc::DesktopFrame* frame =
  45         new webrtc::BasicDesktopFrame(webrtc::DesktopSize(10, 10));
  46     memset(frame->data(), 0, frame->stride() * frame->size().height());
  47     callback_->OnCaptureCompleted(frame);
  48   }
  49
  50   bool GetScreenList(ScreenList* screens) override {
  51     webrtc::ScreenCapturer::Screen screen;
  52     screen.id = 0;
  53     screens->push_back(screen);
  54     return true;
  55   }
  56
  57   bool SelectScreen(webrtc::ScreenId id) override {
  58     EXPECT_EQ(0, id);
  59     return true;
  60   }
  61
  62  protected:
  63   Callback* callback_;
  64
  65   DISALLOW_COPY_AND_ASSIGN(FakeScreenCapturer);
  66 };
  67
  68 class FakeWindowCapturer : public webrtc::WindowCapturer {
  69  public:
  70   FakeWindowCapturer()
  71       : callback_(NULL) {
  72   }
  73   ~FakeWindowCapturer() override {}
  74
  75   void SetWindowList(const WindowList& list) {
  76     base::AutoLock lock(window_list_lock_);
  77     window_list_ = list;
  78   }
  79
  80   // Sets |value| thats going to be used to memset() content of the frames
  81   // generated for |window_id|. By default generated frames are set to zeros.
  82   void SetNextFrameValue(WindowId window_id, int8_t value) {
  83     base::AutoLock lock(frame_values_lock_);
  84     frame_values_[window_id] = value;
  85   }
  86
  87   // webrtc::WindowCapturer implementation.
  88   void Start(Callback* callback) override { callback_ = callback; }
  89
  90   void Capture(const webrtc::DesktopRegion& region) override {
  91     DCHECK(callback_);
  92
  93     base::AutoLock lock(frame_values_lock_);
  94
  95     std::map<WindowId, int8_t>::iterator it =
  96         frame_values_.find(selected_window_id_);
  97     int8_t value = (it != frame_values_.end()) ? it->second : 0;
  98     webrtc::DesktopFrame* frame =
  99         new webrtc::BasicDesktopFrame(webrtc::DesktopSize(10, 10));
 100     memset(frame->data(), value, frame->stride() * frame->size().height());
 101     callback_->OnCaptureCompleted(frame);
 102   }
 103
 104   bool GetWindowList(WindowList* windows) override {
 105     base::AutoLock lock(window_list_lock_);
 106     *windows = window_list_;
 107     return true;
 108   }
 109
 110   bool SelectWindow(WindowId id) override {
 111     selected_window_id_ = id;
 112     return true;
 113   }
 114
 115   bool BringSelectedWindowToFront() override { return true; }
 116
 117  private:
 118   Callback* callback_;
 119   WindowList window_list_;
 120   base::Lock window_list_lock_;
 121
 122   WindowId selected_window_id_;
 123
 124   // Frames to be captured per window.
 125   std::map<WindowId, int8_t> frame_values_;
 126   base::Lock frame_values_lock_;
 127
 128   DISALLOW_COPY_AND_ASSIGN(FakeWindowCapturer);
 129 };
 130
 131 ACTION_P2(CheckListSize, model, expected_list_size) {
 132   EXPECT_EQ(expected_list_size, model->GetSourceCount());
 133 }
 134
 135 ACTION_P(QuitMessageLoop, message_loop) {
 136   message_loop->task_runner()->PostTask(FROM_HERE,
 137                                         base::MessageLoop::QuitClosure());
 138 }
 139
 140 class DesktopMediaListTest : public testing::Test {
 141  public:
 142   DesktopMediaListTest()
 143       : window_capturer_(NULL),
 144         ui_thread_(content::BrowserThread::UI,
 145                    &message_loop_) {
 146   }
 147
 148   void CreateWithDefaultCapturers() {
 149     window_capturer_ = new FakeWindowCapturer();
 150     model_.reset(new NativeDesktopMediaList(
 151         scoped_ptr<webrtc::ScreenCapturer>(new FakeScreenCapturer()),
 152         scoped_ptr<webrtc::WindowCapturer>(window_capturer_)));
 153
 154     // Set update period to reduce the time it takes to run tests.
 155     model_->SetUpdatePeriod(base::TimeDelta::FromMilliseconds(0));
 156   }
 157
 158   webrtc::WindowCapturer::WindowList AddWindowsAndVerify(
 159       size_t count, bool window_only) {
 160     webrtc::WindowCapturer::WindowList list;
 161     for (size_t i = 0; i < count; ++i) {
 162       webrtc::WindowCapturer::Window window;
 163       window.id = i + 1;
 164       window.title = "Test window";
 165       list.push_back(window);
 166     }
 167     window_capturer_->SetWindowList(list);
 168
 169     {
 170       testing::InSequence dummy;
 171       size_t source_count = window_only ? count : count + 1;
 172       for (size_t i = 0; i < source_count; ++i) {
 173         EXPECT_CALL(observer_, OnSourceAdded(i))
 174           .WillOnce(CheckListSize(model_.get(), static_cast<int>(i + 1)));
 175       }
 176       for (size_t i = 0; i < source_count - 1; ++i) {
 177         EXPECT_CALL(observer_, OnSourceThumbnailChanged(i));
 178       }
 179       EXPECT_CALL(observer_, OnSourceThumbnailChanged(source_count - 1))
 180         .WillOnce(QuitMessageLoop(&message_loop_));
 181     }
 182     model_->StartUpdating(&observer_);
 183     message_loop_.Run();
 184
 185     for (size_t i = 0; i < count; ++i) {
 186       size_t source_index = window_only ? i : i + 1;
 187       EXPECT_EQ(model_->GetSource(source_index).id.type,
 188                                   content::DesktopMediaID::TYPE_WINDOW);
 189       EXPECT_EQ(model_->GetSource(source_index).id.id, static_cast<int>(i + 1));
 190       EXPECT_EQ(model_->GetSource(source_index).name,
 191                                   base::UTF8ToUTF16("Test window"));
 192     }
 193     testing::Mock::VerifyAndClearExpectations(&observer_);
 194     return list;
 195   }
 196
 197  protected:
 198   // Must be listed before |model_|, so it's destroyed last.
 199   MockObserver observer_;
 200
 201   // Owned by |model_|;
 202   FakeWindowCapturer* window_capturer_;
 203
 204   scoped_ptr<NativeDesktopMediaList> model_;
 205
 206   base::MessageLoop message_loop_;
 207   content::TestBrowserThread ui_thread_;
 208
 209   DISALLOW_COPY_AND_ASSIGN(DesktopMediaListTest);
 210 };
 211
 212 TEST_F(DesktopMediaListTest, InitialSourceList) {
 213   CreateWithDefaultCapturers();
 214   webrtc::WindowCapturer::WindowList list = AddWindowsAndVerify(1, false);
 215
 216   EXPECT_EQ(model_->GetSource(0).id.type, content::DesktopMediaID::TYPE_SCREEN);
 217   EXPECT_EQ(model_->GetSource(0).id.id, 0);
 218 }
 219
 220 // Verifies that the window specified with SetViewDialogWindowId() is filtered
 221 // from the results.
 222 TEST_F(DesktopMediaListTest, Filtering) {
 223   CreateWithDefaultCapturers();
 224   webrtc::WindowCapturer::WindowList list = AddWindowsAndVerify(2, false);
 225
 226   EXPECT_EQ(model_->GetSource(0).id.type, content::DesktopMediaID::TYPE_SCREEN);
 227   EXPECT_EQ(model_->GetSource(0).id.id, 0);
 228 }
 229
 230 TEST_F(DesktopMediaListTest, WindowsOnly) {
 231   window_capturer_ = new FakeWindowCapturer();
 232   model_.reset(new NativeDesktopMediaList(
 233       scoped_ptr<webrtc::ScreenCapturer>(),
 234       scoped_ptr<webrtc::WindowCapturer>(window_capturer_)));
 235   AddWindowsAndVerify(1, true);
 236 }
 237
 238 TEST_F(DesktopMediaListTest, ScreenOnly) {
 239   model_.reset(new NativeDesktopMediaList(
 240       scoped_ptr<webrtc::ScreenCapturer>(new FakeScreenCapturer),
 241       scoped_ptr<webrtc::WindowCapturer>()));
 242
 243   {
 244     testing::InSequence dummy;
 245     EXPECT_CALL(observer_, OnSourceAdded(0))
 246       .WillOnce(CheckListSize(model_.get(), 1));
 247     EXPECT_CALL(observer_, OnSourceThumbnailChanged(0))
 248       .WillOnce(QuitMessageLoop(&message_loop_));
 249   }
 250   model_->StartUpdating(&observer_);
 251
 252   message_loop_.Run();
 253
 254   EXPECT_EQ(model_->GetSource(0).id.type, content::DesktopMediaID::TYPE_SCREEN);
 255 }
 256
 257 TEST_F(DesktopMediaListTest, AddWindow) {
 258   CreateWithDefaultCapturers();
 259   webrtc::WindowCapturer::WindowList list = AddWindowsAndVerify(1, false);
 260
 261   EXPECT_CALL(observer_, OnSourceAdded(2))
 262     .WillOnce(DoAll(CheckListSize(model_.get(), 3),
 263                     QuitMessageLoop(&message_loop_)));
 264
 265   webrtc::WindowCapturer::Window window;
 266   window.id = 0;
 267   window.title = "Test window 0";
 268   list.push_back(window);
 269   window_capturer_->SetWindowList(list);
 270
 271   message_loop_.Run();
 272
 273   EXPECT_EQ(model_->GetSource(2).id.type, content::DesktopMediaID::TYPE_WINDOW);
 274   EXPECT_EQ(model_->GetSource(2).id.id, 0);
 275 }
 276
 277 TEST_F(DesktopMediaListTest, RemoveWindow) {
 278   CreateWithDefaultCapturers();
 279   webrtc::WindowCapturer::WindowList list = AddWindowsAndVerify(2, false);
 280
 281   EXPECT_CALL(observer_, OnSourceRemoved(2))
 282     .WillOnce(DoAll(CheckListSize(model_.get(), 2),
 283                     QuitMessageLoop(&message_loop_)));
 284
 285   list.erase(list.begin() + 1);
 286   window_capturer_->SetWindowList(list);
 287
 288   message_loop_.Run();
 289 }
 290
 291 TEST_F(DesktopMediaListTest, RemoveAllWindows) {
 292   CreateWithDefaultCapturers();
 293   webrtc::WindowCapturer::WindowList list = AddWindowsAndVerify(2, false);
 294
 295   testing::InSequence seq;
 296   EXPECT_CALL(observer_, OnSourceRemoved(1))
 297     .WillOnce(CheckListSize(model_.get(), 2));
 298   EXPECT_CALL(observer_, OnSourceRemoved(1))
 299     .WillOnce(DoAll(CheckListSize(model_.get(), 1),
 300                     QuitMessageLoop(&message_loop_)));
 301
 302   list.erase(list.begin(), list.end());
 303   window_capturer_->SetWindowList(list);
 304
 305   message_loop_.Run();
 306 }
 307
 308 TEST_F(DesktopMediaListTest, UpdateTitle) {
 309   CreateWithDefaultCapturers();
 310   webrtc::WindowCapturer::WindowList list = AddWindowsAndVerify(1, false);
 311
 312   EXPECT_CALL(observer_, OnSourceNameChanged(1))
 313     .WillOnce(QuitMessageLoop(&message_loop_));
 314
 315   const std::string kTestTitle = "New Title";
 316
 317   list[0].title = kTestTitle;
 318   window_capturer_->SetWindowList(list);
 319
 320   message_loop_.Run();
 321
 322   EXPECT_EQ(model_->GetSource(1).name, base::UTF8ToUTF16(kTestTitle));
 323 }
 324
 325 TEST_F(DesktopMediaListTest, UpdateThumbnail) {
 326   CreateWithDefaultCapturers();
 327   AddWindowsAndVerify(2, false);
 328
 329   EXPECT_CALL(observer_, OnSourceThumbnailChanged(1))
 330     .WillOnce(QuitMessageLoop(&message_loop_));
 331   // Update frame for the window and verify that we get notification about it.
 332   window_capturer_->SetNextFrameValue(1, 1);
 333
 334   message_loop_.Run();
 335 }
 336
 337 TEST_F(DesktopMediaListTest, MoveWindow) {
 338   CreateWithDefaultCapturers();
 339   webrtc::WindowCapturer::WindowList list = AddWindowsAndVerify(2, false);
 340
 341   EXPECT_CALL(observer_, OnSourceMoved(2, 1))
 342     .WillOnce(DoAll(CheckListSize(model_.get(), 3),
 343                     QuitMessageLoop(&message_loop_)));
 344
 345   // Swap the two windows.
 346   webrtc::WindowCapturer::Window temp = list[0];
 347   list[0] = list[1];
 348   list[1] = temp;
 349   window_capturer_->SetWindowList(list);
 350
 351   message_loop_.Run();
 352 }
 353
 354 }  // namespace