WebContentsVideoCaptureDevice: Recover after errors.

content/browser/renderer_host/media/web_contents_video_capture_device_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 "content/browser/renderer_host/media/web_contents_video_capture_device.h"
 
 #include "base/bind_helpers.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/time.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "media/video/capture/video_capture_types.h"
 #include "skia/ext/platform_canvas.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkColor.h"
 
 namespace content {
 namespace {
 const int kTestWidth = 1280;
 const int kTestHeight = 720;
 const int kBytesPerPixel = 4;
 const int kTestFramesPerSecond = 8;
+const base::TimeDelta kWaitTimeout =
+    base::TimeDelta::FromMilliseconds(2000);
 const SkColor kNothingYet = 0xdeadbeef;
 const SkColor kNotInterested = ~kNothingYet;
 }
 
 // A stub implementation which returns solid-color bitmaps in calls to
 // CopyFromBackingStore().  The unit tests can change the color for successive
 // captures.
 class StubRenderWidgetHost : public RenderWidgetHostImpl {
  public:
   StubRenderWidgetHost(RenderProcessHost* process, int routing_id)
       : RenderWidgetHostImpl(&delegate_, process, routing_id),
-        color_(kNothingYet) {}
+        color_(kNothingYet),
+        copy_result_size_(kTestWidth, kTestHeight),
+        copy_event_(false, false) {}
 
   void SetSolidColor(SkColor color) {
     base::AutoLock guard(lock_);
     color_ = color;
   }
 
+  void SetCopyResultSize(int width, int height) {
+    base::AutoLock guard(lock_);
+    copy_result_size_ = gfx::Size(width, height);
+  }
+
+  bool WaitForNextBackingStoreCopy() {
+    if (!copy_event_.TimedWait(kWaitTimeout)) {
+      ADD_FAILURE() << "WaitForNextBackingStoreCopy: wait deadline exceeded";
+      return false;
+    }
+    return true;
+  }
+
+  // RenderWidgetHostImpl overrides.
   virtual void CopyFromBackingStore(
       const gfx::Rect& src_rect,
       const gfx::Size& accelerated_dst_size,
       const base::Callback<void(bool, const SkBitmap&)>& callback) OVERRIDE {
     // Although it's not necessary, use a PlatformBitmap here (instead of a
     // regular SkBitmap) to exercise possible threading issues.
     scoped_ptr<skia::PlatformBitmap> platform_bitmap(new skia::PlatformBitmap);
-    EXPECT_TRUE(platform_bitmap->Allocate(kTestWidth, kTestHeight, false));
+    EXPECT_TRUE(platform_bitmap->Allocate(
+        copy_result_size_.width(), copy_result_size_.height(), false));
     {
       SkAutoLockPixels locker(platform_bitmap->GetBitmap());
       base::AutoLock guard(lock_);
       platform_bitmap->GetBitmap().eraseColor(color_);
     }
 
     callback.Run(true, platform_bitmap->GetBitmap());
+    copy_event_.Signal();
   }
 
  private:
   class StubRenderWidgetHostDelegate : public RenderWidgetHostDelegate {
    public:
     StubRenderWidgetHostDelegate() {}
     virtual ~StubRenderWidgetHostDelegate() {}
 
    private:
     DISALLOW_COPY_AND_ASSIGN(StubRenderWidgetHostDelegate);
   };
 
   StubRenderWidgetHostDelegate delegate_;
   base::Lock lock_;  // Guards changes to color_.
   SkColor color_;
+  gfx::Size copy_result_size_;
+  base::WaitableEvent copy_event_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StubRenderWidgetHost);
 };
 
 // A stub consumer of captured video frames, which checks the output of
 // WebContentsVideoCaptureDevice.
 class StubConsumer : public media::VideoCaptureDevice::EventHandler {
  public:
   StubConsumer() : output_changed_(&lock_),
                    picture_color_(kNothingYet),
                    error_encountered_(false) {}
   virtual ~StubConsumer() {}
 
   // Returns false if an error was encountered.
   bool WaitForNextColorOrError(SkColor expected_color) {
+    base::TimeTicks deadline = base::TimeTicks::Now() + kWaitTimeout;
     base::AutoLock guard(lock_);
     while (picture_color_ != expected_color && !error_encountered_) {
-      output_changed_.Wait();
+      output_changed_.TimedWait(kWaitTimeout);
+      if (base::TimeTicks::Now() >= deadline) {
+        ADD_FAILURE() << "WaitForNextColorOrError: wait deadline exceeded";
+        return false;
+      }
     }
     if (!error_encountered_) {
       EXPECT_EQ(expected_color, picture_color_);
       return true;
     } else {
       return false;
     }
   }
 
   virtual void OnIncomingCapturedFrame(const uint8* data, int length,
@@ skipping 122 matching lines @@
   EXPECT_TRUE(consumer()->WaitForNextColorOrError(SK_ColorBLACK));
 
   device()->DeAllocate();
 }
 
 TEST_F(WebContentsVideoCaptureDeviceTest, RejectsInvalidAllocateParams) {
   device()->Allocate(1280, 720, -2, consumer());
   EXPECT_FALSE(consumer()->WaitForNextColorOrError(kNotInterested));
 }
 
+TEST_F(WebContentsVideoCaptureDeviceTest, BadFramesGoodFrames) {
+  device()->Allocate(kTestWidth, kTestHeight, kTestFramesPerSecond,
+                     consumer());
+
+
+  // 1x1 is too small to process; we intend for this to result in an error.
+  source()->SetCopyResultSize(1, 1);
+  source()->SetSolidColor(SK_ColorRED);
+  device()->Start();
+
+  // These frames ought to be dropped during the Render stage. Let
+  // several captures to happen.
+  ASSERT_TRUE(source()->WaitForNextBackingStoreCopy());
+  ASSERT_TRUE(source()->WaitForNextBackingStoreCopy());
+  ASSERT_TRUE(source()->WaitForNextBackingStoreCopy());
+  ASSERT_TRUE(source()->WaitForNextBackingStoreCopy());
+  ASSERT_TRUE(source()->WaitForNextBackingStoreCopy());
+
+  // Now push some good frames through; they should be processed normally.
+  source()->SetCopyResultSize(kTestWidth, kTestHeight);
+  source()->SetSolidColor(SK_ColorGREEN);
+  EXPECT_TRUE(consumer()->WaitForNextColorOrError(SK_ColorGREEN));
+  source()->SetSolidColor(SK_ColorRED);
+  EXPECT_TRUE(consumer()->WaitForNextColorOrError(SK_ColorRED));
+  device()->DeAllocate();
+}
+
 }  // namespace content