content/browser/media/capture/web_contents_video_capture_device_unittest.cc

   1 // Copyright (c) 2012 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 "content/browser/media/capture/web_contents_video_capture_device.h"
   6
   7 #include "base/bind_helpers.h"
   8 #include "base/debug/debugger.h"
   9 #include "base/run_loop.h"
  10 #include "base/test/test_timeouts.h"
  11 #include "base/time/time.h"
  12 #include "base/timer/timer.h"
  13 #include "content/browser/browser_thread_impl.h"
  14 #include "content/browser/media/capture/video_capture_oracle.h"
  15 #include "content/browser/media/capture/web_contents_capture_util.h"
  16 #include "content/browser/renderer_host/media/video_capture_buffer_pool.h"
  17 #include "content/browser/renderer_host/render_view_host_factory.h"
  18 #include "content/browser/renderer_host/render_widget_host_impl.h"
  19 #include "content/port/browser/render_widget_host_view_frame_subscriber.h"
  20 #include "content/public/browser/notification_service.h"
  21 #include "content/public/browser/notification_types.h"
  22 #include "content/public/test/mock_render_process_host.h"
  23 #include "content/public/test/test_browser_context.h"
  24 #include "content/public/test/test_browser_thread_bundle.h"
  25 #include "content/public/test/test_utils.h"
  26 #include "content/test/test_render_view_host.h"
  27 #include "content/test/test_web_contents.h"
  28 #include "media/base/video_frame.h"
  29 #include "media/base/video_util.h"
  30 #include "media/base/yuv_convert.h"
  31 #include "media/video/capture/video_capture_types.h"
  32 #include "skia/ext/platform_canvas.h"
  33 #include "testing/gtest/include/gtest/gtest.h"
  34 #include "third_party/skia/include/core/SkColor.h"
  35
  36 namespace content {
  37 namespace {
  38
  39 const int kTestWidth = 320;
  40 const int kTestHeight = 240;
  41 const int kTestFramesPerSecond = 20;
  42 const SkColor kNothingYet = 0xdeadbeef;
  43 const SkColor kNotInterested = ~kNothingYet;
  44
  45 void DeadlineExceeded(base::Closure quit_closure) {
  46   if (!base::debug::BeingDebugged()) {
  47     quit_closure.Run();
  48     FAIL() << "Deadline exceeded while waiting, quitting";
  49   } else {
  50     LOG(WARNING) << "Deadline exceeded; test would fail if debugger weren't "
  51                  << "attached.";
  52   }
  53 }
  54
  55 void RunCurrentLoopWithDeadline() {
  56   base::Timer deadline(false, false);
  57   deadline.Start(FROM_HERE, TestTimeouts::action_max_timeout(), base::Bind(
  58       &DeadlineExceeded, base::MessageLoop::current()->QuitClosure()));
  59   base::MessageLoop::current()->Run();
  60   deadline.Stop();
  61 }
  62
  63 SkColor ConvertRgbToYuv(SkColor rgb) {
  64   uint8 yuv[3];
  65   media::ConvertRGB32ToYUV(reinterpret_cast<uint8*>(&rgb),
  66                            yuv, yuv + 1, yuv + 2, 1, 1, 1, 1, 1);
  67   return SkColorSetRGB(yuv[0], yuv[1], yuv[2]);
  68 }
  69
  70 // Thread-safe class that controls the source pattern to be captured by the
  71 // system under test. The lifetime of this class is greater than the lifetime
  72 // of all objects that reference it, so it does not need to be reference
  73 // counted.
  74 class CaptureTestSourceController {
  75  public:
  76
  77   CaptureTestSourceController()
  78       : color_(SK_ColorMAGENTA),
  79         copy_result_size_(kTestWidth, kTestHeight),
  80         can_copy_to_video_frame_(false),
  81         use_frame_subscriber_(false) {}
  82
  83   void SetSolidColor(SkColor color) {
  84     base::AutoLock guard(lock_);
  85     color_ = color;
  86   }
  87
  88   SkColor GetSolidColor() {
  89     base::AutoLock guard(lock_);
  90     return color_;
  91   }
  92
  93   void SetCopyResultSize(int width, int height) {
  94     base::AutoLock guard(lock_);
  95     copy_result_size_ = gfx::Size(width, height);
  96   }
  97
  98   gfx::Size GetCopyResultSize() {
  99     base::AutoLock guard(lock_);
 100     return copy_result_size_;
 101   }
 102
 103   void SignalCopy() {
 104     // TODO(nick): This actually should always be happening on the UI thread.
 105     base::AutoLock guard(lock_);
 106     if (!copy_done_.is_null()) {
 107       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, copy_done_);
 108       copy_done_.Reset();
 109     }
 110   }
 111
 112   void SetCanCopyToVideoFrame(bool value) {
 113     base::AutoLock guard(lock_);
 114     can_copy_to_video_frame_ = value;
 115   }
 116
 117   bool CanCopyToVideoFrame() {
 118     base::AutoLock guard(lock_);
 119     return can_copy_to_video_frame_;
 120   }
 121
 122   void SetUseFrameSubscriber(bool value) {
 123     base::AutoLock guard(lock_);
 124     use_frame_subscriber_ = value;
 125   }
 126
 127   bool CanUseFrameSubscriber() {
 128     base::AutoLock guard(lock_);
 129     return use_frame_subscriber_;
 130   }
 131
 132   void WaitForNextCopy() {
 133     {
 134       base::AutoLock guard(lock_);
 135       copy_done_ = base::MessageLoop::current()->QuitClosure();
 136     }
 137
 138     RunCurrentLoopWithDeadline();
 139   }
 140
 141  private:
 142   base::Lock lock_;  // Guards changes to all members.
 143   SkColor color_;
 144   gfx::Size copy_result_size_;
 145   bool can_copy_to_video_frame_;
 146   bool use_frame_subscriber_;
 147   base::Closure copy_done_;
 148
 149   DISALLOW_COPY_AND_ASSIGN(CaptureTestSourceController);
 150 };
 151
 152 // A stub implementation which returns solid-color bitmaps in calls to
 153 // CopyFromCompositingSurfaceToVideoFrame(), and which allows the video-frame
 154 // readback path to be switched on and off. The behavior is controlled by a
 155 // CaptureTestSourceController.
 156 class CaptureTestView : public TestRenderWidgetHostView {
 157  public:
 158   explicit CaptureTestView(RenderWidgetHostImpl* rwh,
 159                            CaptureTestSourceController* controller)
 160       : TestRenderWidgetHostView(rwh),
 161         controller_(controller) {}
 162
 163   virtual ~CaptureTestView() {}
 164
 165   // TestRenderWidgetHostView overrides.
 166   virtual gfx::Rect GetViewBounds() const OVERRIDE {
 167     return gfx::Rect(100, 100, 100 + kTestWidth, 100 + kTestHeight);
 168   }
 169
 170   virtual bool CanCopyToVideoFrame() const OVERRIDE {
 171     return controller_->CanCopyToVideoFrame();
 172   }
 173
 174   virtual void CopyFromCompositingSurfaceToVideoFrame(
 175       const gfx::Rect& src_subrect,
 176       const scoped_refptr<media::VideoFrame>& target,
 177       const base::Callback<void(bool)>& callback) OVERRIDE {
 178     SkColor c = ConvertRgbToYuv(controller_->GetSolidColor());
 179     media::FillYUV(
 180         target.get(), SkColorGetR(c), SkColorGetG(c), SkColorGetB(c));
 181     callback.Run(true);
 182     controller_->SignalCopy();
 183   }
 184
 185   virtual void BeginFrameSubscription(
 186       scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) OVERRIDE {
 187     subscriber_.reset(subscriber.release());
 188   }
 189
 190   virtual void EndFrameSubscription() OVERRIDE {
 191     subscriber_.reset();
 192   }
 193
 194   // Simulate a compositor paint event for our subscriber.
 195   void SimulateUpdate() {
 196     const base::TimeTicks present_time = base::TimeTicks::Now();
 197     RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback callback;
 198     scoped_refptr<media::VideoFrame> target;
 199     if (subscriber_ && subscriber_->ShouldCaptureFrame(present_time,
 200                                                        &target, &callback)) {
 201       SkColor c = ConvertRgbToYuv(controller_->GetSolidColor());
 202       media::FillYUV(
 203           target.get(), SkColorGetR(c), SkColorGetG(c), SkColorGetB(c));
 204       BrowserThread::PostTask(BrowserThread::UI,
 205                               FROM_HERE,
 206                               base::Bind(callback, present_time, true));
 207       controller_->SignalCopy();
 208     }
 209   }
 210
 211  private:
 212   scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber_;
 213   CaptureTestSourceController* const controller_;
 214
 215   DISALLOW_IMPLICIT_CONSTRUCTORS(CaptureTestView);
 216 };
 217
 218 #if defined(COMPILER_MSVC)
 219 // MSVC warns on diamond inheritance. See comment for same warning on
 220 // RenderViewHostImpl.
 221 #pragma warning(push)
 222 #pragma warning(disable: 4250)
 223 #endif
 224
 225 // A stub implementation which returns solid-color bitmaps in calls to
 226 // CopyFromBackingStore(). The behavior is controlled by a
 227 // CaptureTestSourceController.
 228 class CaptureTestRenderViewHost : public TestRenderViewHost {
 229  public:
 230   CaptureTestRenderViewHost(SiteInstance* instance,
 231                             RenderViewHostDelegate* delegate,
 232                             RenderWidgetHostDelegate* widget_delegate,
 233                             int routing_id,
 234                             int main_frame_routing_id,
 235                             bool swapped_out,
 236                             CaptureTestSourceController* controller)
 237       : TestRenderViewHost(instance, delegate, widget_delegate, routing_id,
 238                            main_frame_routing_id, swapped_out),
 239         controller_(controller) {
 240     // Override the default view installed by TestRenderViewHost; we need
 241     // our special subclass which has mocked-out tab capture support.
 242     RenderWidgetHostView* old_view = GetView();
 243     SetView(new CaptureTestView(this, controller));
 244     delete old_view;
 245   }
 246
 247   // TestRenderViewHost overrides.
 248   virtual void CopyFromBackingStore(
 249       const gfx::Rect& src_rect,
 250       const gfx::Size& accelerated_dst_size,
 251       const base::Callback<void(bool, const SkBitmap&)>& callback,
 252       const SkBitmap::Config& bitmap_config) OVERRIDE {
 253     gfx::Size size = controller_->GetCopyResultSize();
 254     SkColor color = controller_->GetSolidColor();
 255
 256     // Although it's not necessary, use a PlatformBitmap here (instead of a
 257     // regular SkBitmap) to exercise possible threading issues.
 258     skia::PlatformBitmap output;
 259     EXPECT_TRUE(output.Allocate(size.width(), size.height(), false));
 260     {
 261       SkAutoLockPixels locker(output.GetBitmap());
 262       output.GetBitmap().eraseColor(color);
 263     }
 264     callback.Run(true, output.GetBitmap());
 265     controller_->SignalCopy();
 266   }
 267
 268  private:
 269   CaptureTestSourceController* controller_;
 270
 271   DISALLOW_IMPLICIT_CONSTRUCTORS(CaptureTestRenderViewHost);
 272 };
 273
 274 #if defined(COMPILER_MSVC)
 275 // Re-enable warning 4250
 276 #pragma warning(pop)
 277 #endif
 278
 279 class CaptureTestRenderViewHostFactory : public RenderViewHostFactory {
 280  public:
 281   explicit CaptureTestRenderViewHostFactory(
 282       CaptureTestSourceController* controller) : controller_(controller) {
 283     RegisterFactory(this);
 284   }
 285
 286   virtual ~CaptureTestRenderViewHostFactory() {
 287     UnregisterFactory();
 288   }
 289
 290   // RenderViewHostFactory implementation.
 291   virtual RenderViewHost* CreateRenderViewHost(
 292       SiteInstance* instance,
 293       RenderViewHostDelegate* delegate,
 294       RenderWidgetHostDelegate* widget_delegate,
 295       int routing_id,
 296       int main_frame_routing_id,
 297       bool swapped_out) OVERRIDE {
 298     return new CaptureTestRenderViewHost(instance, delegate, widget_delegate,
 299                                          routing_id, main_frame_routing_id,
 300                                          swapped_out, controller_);
 301   }
 302  private:
 303   CaptureTestSourceController* controller_;
 304
 305   DISALLOW_IMPLICIT_CONSTRUCTORS(CaptureTestRenderViewHostFactory);
 306 };
 307
 308 // A stub consumer of captured video frames, which checks the output of
 309 // WebContentsVideoCaptureDevice.
 310 class StubClient : public media::VideoCaptureDevice::Client {
 311  public:
 312   StubClient(const base::Callback<void(SkColor)>& color_callback,
 313              const base::Closure& error_callback)
 314       : color_callback_(color_callback),
 315         error_callback_(error_callback) {
 316     buffer_pool_ = new VideoCaptureBufferPool(2);
 317   }
 318   virtual ~StubClient() {}
 319
 320   virtual scoped_refptr<media::VideoCaptureDevice::Client::Buffer>
 321   ReserveOutputBuffer(media::VideoFrame::Format format,
 322                       const gfx::Size& dimensions) OVERRIDE {
 323     CHECK_EQ(format, media::VideoFrame::I420);
 324     const size_t frame_bytes =
 325         media::VideoFrame::AllocationSize(media::VideoFrame::I420, dimensions);
 326     int buffer_id_to_drop = VideoCaptureBufferPool::kInvalidId;  // Ignored.
 327     int buffer_id =
 328         buffer_pool_->ReserveForProducer(frame_bytes, &buffer_id_to_drop);
 329     if (buffer_id == VideoCaptureBufferPool::kInvalidId)
 330       return NULL;
 331     void* data;
 332     size_t size;
 333     buffer_pool_->GetBufferInfo(buffer_id, &data, &size);
 334     return scoped_refptr<media::VideoCaptureDevice::Client::Buffer>(
 335         new PoolBuffer(buffer_pool_, buffer_id, data, size));
 336   }
 337
 338   virtual void OnIncomingCapturedData(
 339       const uint8* data,
 340       int length,
 341       const media::VideoCaptureFormat& frame_format,
 342       int rotation,
 343       base::TimeTicks timestamp) OVERRIDE {
 344     FAIL();
 345   }
 346
 347   virtual void OnIncomingCapturedVideoFrame(
 348       const scoped_refptr<Buffer>& buffer,
 349       const media::VideoCaptureFormat& buffer_format,
 350       const scoped_refptr<media::VideoFrame>& frame,
 351       base::TimeTicks timestamp) OVERRIDE {
 352     EXPECT_EQ(gfx::Size(kTestWidth, kTestHeight), buffer_format.frame_size);
 353     EXPECT_EQ(media::PIXEL_FORMAT_I420, buffer_format.pixel_format);
 354     EXPECT_EQ(media::VideoFrame::I420, frame->format());
 355     uint8 yuv[3];
 356     for (int plane = 0; plane < 3; ++plane)
 357       yuv[plane] = frame->data(plane)[0];
 358     // TODO(nick): We just look at the first pixel presently, because if
 359     // the analysis is too slow, the backlog of frames will grow without bound
 360     // and trouble erupts. http://crbug.com/174519
 361     color_callback_.Run((SkColorSetRGB(yuv[0], yuv[1], yuv[2])));
 362   }
 363
 364   virtual void OnError(const std::string& reason) OVERRIDE {
 365     error_callback_.Run();
 366   }
 367
 368  private:
 369   class PoolBuffer : public media::VideoCaptureDevice::Client::Buffer {
 370    public:
 371     PoolBuffer(const scoped_refptr<VideoCaptureBufferPool>& pool,
 372                int buffer_id,
 373                void* data,
 374                size_t size)
 375         : Buffer(buffer_id, data, size), pool_(pool) {}
 376
 377    private:
 378     virtual ~PoolBuffer() { pool_->RelinquishProducerReservation(id()); }
 379     const scoped_refptr<VideoCaptureBufferPool> pool_;
 380   };
 381
 382   scoped_refptr<VideoCaptureBufferPool> buffer_pool_;
 383   base::Callback<void(SkColor)> color_callback_;
 384   base::Closure error_callback_;
 385
 386   DISALLOW_COPY_AND_ASSIGN(StubClient);
 387 };
 388
 389 class StubClientObserver {
 390  public:
 391   StubClientObserver()
 392       : error_encountered_(false),
 393         wait_color_yuv_(0xcafe1950) {
 394     client_.reset(new StubClient(
 395         base::Bind(&StubClientObserver::OnColor, base::Unretained(this)),
 396         base::Bind(&StubClientObserver::OnError, base::Unretained(this))));
 397   }
 398
 399   virtual ~StubClientObserver() {}
 400
 401   scoped_ptr<media::VideoCaptureDevice::Client> PassClient() {
 402     return client_.PassAs<media::VideoCaptureDevice::Client>();
 403   }
 404
 405   void QuitIfConditionMet(SkColor color) {
 406     base::AutoLock guard(lock_);
 407     if (wait_color_yuv_ == color || error_encountered_)
 408       base::MessageLoop::current()->Quit();
 409   }
 410
 411   void WaitForNextColor(SkColor expected_color) {
 412     {
 413       base::AutoLock guard(lock_);
 414       wait_color_yuv_ = ConvertRgbToYuv(expected_color);
 415       error_encountered_ = false;
 416     }
 417     RunCurrentLoopWithDeadline();
 418     {
 419       base::AutoLock guard(lock_);
 420       ASSERT_FALSE(error_encountered_);
 421     }
 422   }
 423
 424   void WaitForError() {
 425     {
 426       base::AutoLock guard(lock_);
 427       wait_color_yuv_ = kNotInterested;
 428       error_encountered_ = false;
 429     }
 430     RunCurrentLoopWithDeadline();
 431     {
 432       base::AutoLock guard(lock_);
 433       ASSERT_TRUE(error_encountered_);
 434     }
 435   }
 436
 437   bool HasError() {
 438     base::AutoLock guard(lock_);
 439     return error_encountered_;
 440   }
 441
 442   void OnError() {
 443     {
 444       base::AutoLock guard(lock_);
 445       error_encountered_ = true;
 446     }
 447     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
 448         &StubClientObserver::QuitIfConditionMet,
 449         base::Unretained(this),
 450         kNothingYet));
 451   }
 452
 453   void OnColor(SkColor color) {
 454     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
 455         &StubClientObserver::QuitIfConditionMet,
 456         base::Unretained(this),
 457         color));
 458   }
 459
 460  private:
 461   base::Lock lock_;
 462   bool error_encountered_;
 463   SkColor wait_color_yuv_;
 464   scoped_ptr<StubClient> client_;
 465
 466   DISALLOW_COPY_AND_ASSIGN(StubClientObserver);
 467 };
 468
 469 // Test harness that sets up a minimal environment with necessary stubs.
 470 class WebContentsVideoCaptureDeviceTest : public testing::Test {
 471  public:
 472   // This is public because C++ method pointer scoping rules are silly and make
 473   // this hard to use with Bind().
 474   void ResetWebContents() {
 475     web_contents_.reset();
 476   }
 477
 478  protected:
 479   virtual void SetUp() {
 480     // TODO(nick): Sadness and woe! Much "mock-the-world" boilerplate could be
 481     // eliminated here, if only we could use RenderViewHostTestHarness. The
 482     // catch is that we need our TestRenderViewHost to support a
 483     // CopyFromBackingStore operation that we control. To accomplish that,
 484     // either RenderViewHostTestHarness would have to support installing a
 485     // custom RenderViewHostFactory, or else we implant some kind of delegated
 486     // CopyFromBackingStore functionality into TestRenderViewHost itself.
 487
 488     render_process_host_factory_.reset(new MockRenderProcessHostFactory());
 489     // Create our (self-registering) RVH factory, so that when we create a
 490     // WebContents, it in turn creates CaptureTestRenderViewHosts.
 491     render_view_host_factory_.reset(
 492         new CaptureTestRenderViewHostFactory(&controller_));
 493
 494     browser_context_.reset(new TestBrowserContext());
 495
 496     scoped_refptr<SiteInstance> site_instance =
 497         SiteInstance::Create(browser_context_.get());
 498     SiteInstanceImpl::set_render_process_host_factory(
 499         render_process_host_factory_.get());
 500     web_contents_.reset(
 501         TestWebContents::Create(browser_context_.get(), site_instance.get()));
 502
 503     // This is actually a CaptureTestRenderViewHost.
 504     RenderWidgetHostImpl* rwh =
 505         RenderWidgetHostImpl::From(web_contents_->GetRenderViewHost());
 506
 507     std::string device_id =
 508         WebContentsCaptureUtil::AppendWebContentsDeviceScheme(
 509             base::StringPrintf("%d:%d", rwh->GetProcess()->GetID(),
 510                                rwh->GetRoutingID()));
 511
 512     device_.reset(WebContentsVideoCaptureDevice::Create(device_id));
 513
 514     base::RunLoop().RunUntilIdle();
 515   }
 516
 517   virtual void TearDown() {
 518     // Tear down in opposite order of set-up.
 519
 520     // The device is destroyed asynchronously, and will notify the
 521     // CaptureTestSourceController when it finishes destruction.
 522     // Trigger this, and wait.
 523     if (device_) {
 524       device_->StopAndDeAllocate();
 525       device_.reset();
 526     }
 527
 528     base::RunLoop().RunUntilIdle();
 529
 530     // Destroy the browser objects.
 531     web_contents_.reset();
 532     browser_context_.reset();
 533
 534     base::RunLoop().RunUntilIdle();
 535
 536     SiteInstanceImpl::set_render_process_host_factory(NULL);
 537     render_view_host_factory_.reset();
 538     render_process_host_factory_.reset();
 539   }
 540
 541   // Accessors.
 542   CaptureTestSourceController* source() { return &controller_; }
 543   media::VideoCaptureDevice* device() { return device_.get(); }
 544
 545   void SimulateDrawEvent() {
 546     if (source()->CanUseFrameSubscriber()) {
 547       // Print
 548       CaptureTestView* test_view = static_cast<CaptureTestView*>(
 549           web_contents_->GetRenderViewHost()->GetView());
 550       test_view->SimulateUpdate();
 551     } else {
 552       // Simulate a non-accelerated paint.
 553       NotificationService::current()->Notify(
 554           NOTIFICATION_RENDER_WIDGET_HOST_DID_UPDATE_BACKING_STORE,
 555           Source<RenderWidgetHost>(web_contents_->GetRenderViewHost()),
 556           NotificationService::NoDetails());
 557     }
 558   }
 559
 560   void DestroyVideoCaptureDevice() { device_.reset(); }
 561
 562   StubClientObserver* client_observer() {
 563     return &client_observer_;
 564   }
 565
 566  private:
 567   StubClientObserver client_observer_;
 568
 569   // The controller controls which pixel patterns to produce.
 570   CaptureTestSourceController controller_;
 571
 572   // Self-registering RenderProcessHostFactory.
 573   scoped_ptr<MockRenderProcessHostFactory> render_process_host_factory_;
 574
 575   // Creates capture-capable RenderViewHosts whose pixel content production is
 576   // under the control of |controller_|.
 577   scoped_ptr<CaptureTestRenderViewHostFactory> render_view_host_factory_;
 578
 579   // A mocked-out browser and tab.
 580   scoped_ptr<TestBrowserContext> browser_context_;
 581   scoped_ptr<WebContents> web_contents_;
 582
 583   // Finally, the WebContentsVideoCaptureDevice under test.
 584   scoped_ptr<media::VideoCaptureDevice> device_;
 585
 586   TestBrowserThreadBundle thread_bundle_;
 587 };
 588
 589 TEST_F(WebContentsVideoCaptureDeviceTest, InvalidInitialWebContentsError) {
 590   // Before the installs itself on the UI thread up to start capturing, we'll
 591   // delete the web contents. This should trigger an error which can happen in
 592   // practice; we should be able to recover gracefully.
 593   ResetWebContents();
 594
 595   media::VideoCaptureParams capture_params;
 596   capture_params.requested_format.frame_size.SetSize(kTestWidth, kTestHeight);
 597   capture_params.requested_format.frame_rate = kTestFramesPerSecond;
 598   capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
 599   capture_params.allow_resolution_change = false;
 600   device()->AllocateAndStart(capture_params, client_observer()->PassClient());
 601   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForError());
 602   device()->StopAndDeAllocate();
 603 }
 604
 605 TEST_F(WebContentsVideoCaptureDeviceTest, WebContentsDestroyed) {
 606   // We'll simulate the tab being closed after the capture pipeline is up and
 607   // running.
 608   media::VideoCaptureParams capture_params;
 609   capture_params.requested_format.frame_size.SetSize(kTestWidth, kTestHeight);
 610   capture_params.requested_format.frame_rate = kTestFramesPerSecond;
 611   capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
 612   capture_params.allow_resolution_change = false;
 613   device()->AllocateAndStart(capture_params, client_observer()->PassClient());
 614   // Do one capture to prove
 615   source()->SetSolidColor(SK_ColorRED);
 616   SimulateDrawEvent();
 617   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorRED));
 618
 619   base::RunLoop().RunUntilIdle();
 620
 621   // Post a task to close the tab. We should see an error reported to the
 622   // consumer.
 623   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 624       base::Bind(&WebContentsVideoCaptureDeviceTest::ResetWebContents,
 625                  base::Unretained(this)));
 626   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForError());
 627   device()->StopAndDeAllocate();
 628 }
 629
 630 TEST_F(WebContentsVideoCaptureDeviceTest,
 631        StopDeviceBeforeCaptureMachineCreation) {
 632   media::VideoCaptureParams capture_params;
 633   capture_params.requested_format.frame_size.SetSize(kTestWidth, kTestHeight);
 634   capture_params.requested_format.frame_rate = kTestFramesPerSecond;
 635   capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
 636   capture_params.allow_resolution_change = false;
 637   device()->AllocateAndStart(capture_params, client_observer()->PassClient());
 638
 639   // Make a point of not running the UI messageloop here.
 640   device()->StopAndDeAllocate();
 641   DestroyVideoCaptureDevice();
 642
 643   // Currently, there should be CreateCaptureMachineOnUIThread() and
 644   // DestroyCaptureMachineOnUIThread() tasks pending on the current (UI) message
 645   // loop. These should both succeed without crashing, and the machine should
 646   // wind up in the idle state.
 647   base::RunLoop().RunUntilIdle();
 648 }
 649
 650 TEST_F(WebContentsVideoCaptureDeviceTest, StopWithRendererWorkToDo) {
 651   // Set up the test to use RGB copies and an normal
 652   source()->SetCanCopyToVideoFrame(false);
 653   source()->SetUseFrameSubscriber(false);
 654   media::VideoCaptureParams capture_params;
 655   capture_params.requested_format.frame_size.SetSize(kTestWidth, kTestHeight);
 656   capture_params.requested_format.frame_rate = kTestFramesPerSecond;
 657   capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
 658   capture_params.allow_resolution_change = false;
 659   device()->AllocateAndStart(capture_params, client_observer()->PassClient());
 660
 661   base::RunLoop().RunUntilIdle();
 662
 663   for (int i = 0; i < 10; ++i)
 664     SimulateDrawEvent();
 665
 666   ASSERT_FALSE(client_observer()->HasError());
 667   device()->StopAndDeAllocate();
 668   ASSERT_FALSE(client_observer()->HasError());
 669   base::RunLoop().RunUntilIdle();
 670   ASSERT_FALSE(client_observer()->HasError());
 671 }
 672
 673 TEST_F(WebContentsVideoCaptureDeviceTest, DeviceRestart) {
 674   media::VideoCaptureParams capture_params;
 675   capture_params.requested_format.frame_size.SetSize(kTestWidth, kTestHeight);
 676   capture_params.requested_format.frame_rate = kTestFramesPerSecond;
 677   capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
 678   capture_params.allow_resolution_change = false;
 679   device()->AllocateAndStart(capture_params, client_observer()->PassClient());
 680   base::RunLoop().RunUntilIdle();
 681   source()->SetSolidColor(SK_ColorRED);
 682   SimulateDrawEvent();
 683   SimulateDrawEvent();
 684   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorRED));
 685   SimulateDrawEvent();
 686   SimulateDrawEvent();
 687   source()->SetSolidColor(SK_ColorGREEN);
 688   SimulateDrawEvent();
 689   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorGREEN));
 690   device()->StopAndDeAllocate();
 691
 692   // Device is stopped, but content can still be animating.
 693   SimulateDrawEvent();
 694   SimulateDrawEvent();
 695   base::RunLoop().RunUntilIdle();
 696
 697   StubClientObserver observer2;
 698   device()->AllocateAndStart(capture_params, observer2.PassClient());
 699   source()->SetSolidColor(SK_ColorBLUE);
 700   SimulateDrawEvent();
 701   ASSERT_NO_FATAL_FAILURE(observer2.WaitForNextColor(SK_ColorBLUE));
 702   source()->SetSolidColor(SK_ColorYELLOW);
 703   SimulateDrawEvent();
 704   ASSERT_NO_FATAL_FAILURE(observer2.WaitForNextColor(SK_ColorYELLOW));
 705   device()->StopAndDeAllocate();
 706 }
 707
 708 // The "happy case" test.  No scaling is needed, so we should be able to change
 709 // the picture emitted from the source and expect to see each delivered to the
 710 // consumer. The test will alternate between the three capture paths, simulating
 711 // falling in and out of accelerated compositing.
 712 TEST_F(WebContentsVideoCaptureDeviceTest, GoesThroughAllTheMotions) {
 713   media::VideoCaptureParams capture_params;
 714   capture_params.requested_format.frame_size.SetSize(kTestWidth, kTestHeight);
 715   capture_params.requested_format.frame_rate = kTestFramesPerSecond;
 716   capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
 717   capture_params.allow_resolution_change = false;
 718   device()->AllocateAndStart(capture_params, client_observer()->PassClient());
 719
 720   for (int i = 0; i < 6; i++) {
 721     const char* name = NULL;
 722     switch (i % 3) {
 723       case 0:
 724         source()->SetCanCopyToVideoFrame(true);
 725         source()->SetUseFrameSubscriber(false);
 726         name = "VideoFrame";
 727         break;
 728       case 1:
 729         source()->SetCanCopyToVideoFrame(false);
 730         source()->SetUseFrameSubscriber(true);
 731         name = "Subscriber";
 732         break;
 733       case 2:
 734         source()->SetCanCopyToVideoFrame(false);
 735         source()->SetUseFrameSubscriber(false);
 736         name = "SkBitmap";
 737         break;
 738       default:
 739         FAIL();
 740     }
 741
 742     SCOPED_TRACE(base::StringPrintf("Using %s path, iteration #%d", name, i));
 743
 744     source()->SetSolidColor(SK_ColorRED);
 745     SimulateDrawEvent();
 746     ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorRED));
 747
 748     source()->SetSolidColor(SK_ColorGREEN);
 749     SimulateDrawEvent();
 750     ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorGREEN));
 751
 752     source()->SetSolidColor(SK_ColorBLUE);
 753     SimulateDrawEvent();
 754     ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorBLUE));
 755
 756     source()->SetSolidColor(SK_ColorBLACK);
 757     SimulateDrawEvent();
 758     ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorBLACK));
 759   }
 760   device()->StopAndDeAllocate();
 761 }
 762
 763 TEST_F(WebContentsVideoCaptureDeviceTest, RejectsInvalidAllocateParams) {
 764   media::VideoCaptureParams capture_params;
 765   capture_params.requested_format.frame_size.SetSize(1280, 720);
 766   capture_params.requested_format.frame_rate = -2;
 767   capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
 768   capture_params.allow_resolution_change = false;
 769   BrowserThread::PostTask(
 770       BrowserThread::UI,
 771       FROM_HERE,
 772       base::Bind(&media::VideoCaptureDevice::AllocateAndStart,
 773                  base::Unretained(device()),
 774                  capture_params,
 775                  base::Passed(client_observer()->PassClient())));
 776   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForError());
 777   BrowserThread::PostTask(
 778       BrowserThread::UI,
 779       FROM_HERE,
 780       base::Bind(&media::VideoCaptureDevice::StopAndDeAllocate,
 781                  base::Unretained(device())));
 782   base::RunLoop().RunUntilIdle();
 783 }
 784
 785 TEST_F(WebContentsVideoCaptureDeviceTest, BadFramesGoodFrames) {
 786   media::VideoCaptureParams capture_params;
 787   capture_params.requested_format.frame_size.SetSize(kTestWidth, kTestHeight);
 788   capture_params.requested_format.frame_rate = kTestFramesPerSecond;
 789   capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
 790   capture_params.allow_resolution_change = false;
 791   // 1x1 is too small to process; we intend for this to result in an error.
 792   source()->SetCopyResultSize(1, 1);
 793   source()->SetSolidColor(SK_ColorRED);
 794   device()->AllocateAndStart(capture_params, client_observer()->PassClient());
 795
 796   // These frames ought to be dropped during the Render stage. Let
 797   // several captures to happen.
 798   ASSERT_NO_FATAL_FAILURE(source()->WaitForNextCopy());
 799   ASSERT_NO_FATAL_FAILURE(source()->WaitForNextCopy());
 800   ASSERT_NO_FATAL_FAILURE(source()->WaitForNextCopy());
 801   ASSERT_NO_FATAL_FAILURE(source()->WaitForNextCopy());
 802   ASSERT_NO_FATAL_FAILURE(source()->WaitForNextCopy());
 803
 804   // Now push some good frames through; they should be processed normally.
 805   source()->SetCopyResultSize(kTestWidth, kTestHeight);
 806   source()->SetSolidColor(SK_ColorGREEN);
 807   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorGREEN));
 808   source()->SetSolidColor(SK_ColorRED);
 809   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorRED));
 810
 811   device()->StopAndDeAllocate();
 812 }
 813
 814 }  // namespace
 815 }  // namespace content