Allow CopyFromBackingStore to fallback to copying from the renderer side if the accelerated surface…

content/browser/renderer_host/render_widget_host_view_win.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/render_widget_host_view_win.h"
 
 #include <InputScope.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 32 matching lines @@
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/common/process_type.h"
+#include "media/base/video_util.h"
 #include "skia/ext/skia_utils_win.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositionUnderline.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/win/WebInputEventFactory.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/win/WebScreenInfoFactory.h"
 #include "ui/base/events/event.h"
 #include "ui/base/events/event_utils.h"
 #include "ui/base/ime/composition_text.h"
 #include "ui/base/ime/win/tsf_input_scope.h"
@@ skipping 244 matching lines @@
   return pinch_allowed;
 }
 
 void GetScreenInfoForWindow(WebKit::WebScreenInfo* results,
                             gfx::NativeViewId id) {
   *results = WebKit::WebScreenInfoFactory::screenInfo(
       gfx::NativeViewFromId(id));
   results->deviceScaleFactor = ui::win::GetDeviceScaleFactor();
 }
 
+void CopySnapshotToVideoFrame(const scoped_refptr<media::VideoFrame>& target,
+                              const gfx::Rect& region_in_frame,
+                              const base::Callback<void(bool)>& callback,
+                              bool succeed,
+                              const SkBitmap& bitmap) {
+  if (!succeed) {
+    callback.Run(false);
+    return;
+  }
+
+  DCHECK(region_in_frame.size() == gfx::Size(bitmap.width(), bitmap.height()));
+  {
+    SkAutoLockPixels lock(bitmap);
+    media::CopyRGBToVideoFrame(
+        reinterpret_cast<const uint8*>(bitmap.getPixels()),
+        bitmap.rowBytes(),
+        region_in_frame,
+        target.get());
+  }
+  callback.Run(true);
+}
+
 }  // namespace
 
 const wchar_t kRenderWidgetHostHWNDClass[] = L"Chrome_RenderWidgetHostHWND";
 
 // Wrapper for maintaining touchstate associated with a WebTouchEvent.
 class WebTouchState {
  public:
   explicit WebTouchState(const RenderWidgetHostViewWin* window);
 
   // Updates the current touchpoint state with the supplied touches.
@@ skipping 507 matching lines @@
     const gfx::Size& size) {
   return new BackingStoreWin(render_widget_host_, size);
 }
 
 void RenderWidgetHostViewWin::CopyFromCompositingSurface(
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     const base::Callback<void(bool, const SkBitmap&)>& callback) {
   base::ScopedClosureRunner scoped_callback_runner(
       base::Bind(callback, false, SkBitmap()));
-  if (!accelerated_surface_.get())
-    return;
-
   if (dst_size.IsEmpty() || src_subrect.IsEmpty())
     return;
 
   scoped_callback_runner.Release();
-  accelerated_surface_->AsyncCopyTo(src_subrect, dst_size, callback);
+
+  if (!accelerated_surface_.get()) {
+    // If we don't have an accelerated surface then copying from browser side
+    // will fail, so try a slower copy from renderer side instead.
+    render_widget_host_->GetSnapshotFromRenderer(
+        src_subrect, dst_size, callback);
+  } else {
+    accelerated_surface_->AsyncCopyTo(src_subrect, dst_size, callback);
+  }
 }
 
 void RenderWidgetHostViewWin::CopyFromCompositingSurfaceToVideoFrame(
     const gfx::Rect& src_subrect,
     const scoped_refptr<media::VideoFrame>& target,
     const base::Callback<void(bool)>& callback) {
   base::ScopedClosureRunner scoped_callback_runner(base::Bind(callback, false));
-  if (!accelerated_surface_.get())
-    return;
 
   if (!target || target->format() != media::VideoFrame::YV12)
     return;
 
   if (src_subrect.IsEmpty())
     return;
 
   scoped_callback_runner.Release();
-  accelerated_surface_->AsyncCopyToVideoFrame(src_subrect, target, callback);
+
+  if (!accelerated_surface_.get()) {
+    // Compute the dest size we want after the letterboxing resize. Make the
+    // coordinates and sizes even because we letterbox in YUV space
+    // (see CopyRGBToVideoFrame). They need to be even for the UV samples to
+    // line up correctly.
+    gfx::Rect region_in_frame =
+        media::ComputeLetterboxRegion(gfx::Rect(target->coded_size()),
+                                      src_subrect.size());
+    region_in_frame = gfx::Rect(region_in_frame.x() & ~1,
+                                region_in_frame.y() & ~1,
+                                region_in_frame.width() & ~1,
+                                region_in_frame.height() & ~1);
+
+    // If we don't have an accelerated surface then copying from browser side
+    // will fail, so try a slower copy from renderer side instead.
+    render_widget_host_->GetSnapshotFromRenderer(
+        src_subrect, region_in_frame.size(), base::Bind(
+            CopySnapshotToVideoFrame, target, region_in_frame, callback));
+  } else {
+    accelerated_surface_->AsyncCopyToVideoFrame(src_subrect, target, callback);
+  }
 }
 
 bool RenderWidgetHostViewWin::CanCopyToVideoFrame() const {
   return accelerated_surface_.get() && render_widget_host_ &&
       render_widget_host_->is_accelerated_compositing_active();
 }
 
 void RenderWidgetHostViewWin::SetBackground(const SkBitmap& background) {
   RenderWidgetHostViewBase::SetBackground(background);
   render_widget_host_->SetBackground(background);
@@ skipping 2222 matching lines @@
   return new RenderWidgetHostViewWin(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(
       WebKit::WebScreenInfo* results) {
   GetScreenInfoForWindow(results, 0);
 }
 
 }  // namespace content