Implement webview.captureVisibleRegion()

content/browser/frame_host/render_widget_host_view_child_frame.cc

 // Copyright 2014 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/frame_host/render_widget_host_view_child_frame.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "build/build_config.h"
+#include "cc/output/copy_output_request.h"
+#include "cc/output/copy_output_result.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/surfaces/surface_sequence.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/browser_plugin/browser_plugin_guest.h"
 #include "content/browser/compositor/surface_utils.h"
 #include "content/browser/frame_host/cross_process_frame_connector.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
@@ skipping 55 matching lines @@
 void RenderWidgetHostViewChildFrame::Focus() {
 }
 
 bool RenderWidgetHostViewChildFrame::HasFocus() const {
   if (frame_connector_)
     return frame_connector_->HasFocus();
   return false;
 }
 
 bool RenderWidgetHostViewChildFrame::IsSurfaceAvailableForCopy() const {
-  NOTIMPLEMENTED();
-  return false;
+  return surface_factory_ && !surface_id_.is_null();
 }
 
 void RenderWidgetHostViewChildFrame::Show() {
   if (!host_->is_hidden())
     return;
   host_->WasShown(ui::LatencyInfo());
 }
 
 void RenderWidgetHostViewChildFrame::Hide() {
   if (host_->is_hidden())
@@ skipping 148 matching lines @@
                                                   cc::SurfaceDrawStatus drawn) {
   cc::CompositorFrameAck ack;
   DCHECK_GT(ack_pending_count_, 0U);
   if (!surface_returned_resources_.empty())
     ack.resources.swap(surface_returned_resources_);
   if (host_) {
     host_->Send(new ViewMsg_SwapCompositorFrameAck(host_->GetRoutingID(),
                                                    output_surface_id, ack));
   }
   ack_pending_count_--;
+
+  // We only use callbacks once, therefore we make a new list for registration
+  // before we start, and discard the old list entries when we are done.
+  FrameDrawnCallbackList process_callbacks;
+  process_callbacks.swap(frame_drawn_callbacks_);
+  for (scoped_ptr<base::Closure>& callback : process_callbacks)
+    callback->Run();
 }
 
 void RenderWidgetHostViewChildFrame::OnSwapCompositorFrame(
     uint32_t output_surface_id,
     scoped_ptr<cc::CompositorFrame> frame) {
   last_scroll_offset_ = frame->metadata.root_scroll_offset;
 
   if (!frame_connector_)
     return;
 
@@ skipping 151 matching lines @@
 
 void RenderWidgetHostViewChildFrame::StopSpeaking() {
 }
 
 bool RenderWidgetHostViewChildFrame::PostProcessEventForPluginIme(
       const NativeWebKeyboardEvent& event) {
   return false;
 }
 #endif  // defined(OS_MACOSX)
 
+void RenderWidgetHostViewChildFrame::RegisterFrameDrawnCallback(
+    scoped_ptr<base::Closure> callback) {
+  frame_drawn_callbacks_.push_back(std::move(callback));
+}
+
 void RenderWidgetHostViewChildFrame::CopyFromCompositingSurface(
-    const gfx::Rect& /* src_subrect */,
-    const gfx::Size& /* dst_size */,
+    const gfx::Rect& src_subrect,
+    const gfx::Size& output_size,
     const ReadbackRequestCallback& callback,
-    const SkColorType /* preferred_color_type */) {
-  callback.Run(SkBitmap(), READBACK_FAILED);
+    const SkColorType preferred_color_type) {
+  if (!IsSurfaceAvailableForCopy()) {

[ncarter (slow), 2016/01/27 21:08:24]

This behavior goes somewhat against the intended contract of
CopyFromCompositingSurface (which is a conversation between RenderWidgetHostImpl
and its View).

RenderWidgetHost's callers are supposed to be able to tell when a copy would not
succeed due to a lack of a surface, by querying
RenderWidgetHost::CanCopyFromBackingStore prior to calling
RenderWidgetHost::CopyFromBackingStore.

I wonder if there's a satisfactory way to implement "wait until frame ready"
using existing primitives of the content public api? Maybe by installing a
FrameSubscriber to be notified when frames are available? It's not clear how
well this will work for the RWHVChildFrame case.

[wjmaclean, 2016/01/27 21:28:01]

I guess having a surface ID may not be enough, but I'm not sure.

Presumably one could simply, each time a new surface is created, keep track of
the next draw ack to know it actually has pixels, though also those pixels could
presumably disappear if we're not careful (I was willing to just let the
existing system indicate that readback failed in that case, or we could force a
re-composite).

+    // Defer submitting the copy request until after a frame is drawn, at which
+    // point we should be guaranteed that the surface is available.
+    RegisterFrameDrawnCallback(make_scoped_ptr(new base::Closure(base::Bind(

[piman, 2016/01/29 04:29:46]

Why waiting for the frame to be *drawn* (SurfaceDrawn), as opposed to *received*
(OnSwapCompositorFrame)?

Once you received the frame from the renderer, it should be fine to add the copy
request, which will be processed when compositing the next browser frame.

If you wait untilthe next browser frame is drawn, then:
- you incur an extra frame of latency
- you'll kick off yet another browser frame to process the copy request, when
possibly none would be have needed otherwise.

[wjmaclean, 2016/01/29 21:01:57]

I didn't realize that would happen, thanks for pointing it out! I'll revise and
upload a new CL.

+        &RenderWidgetHostViewChildFrame::SubmitSurfaceCopyRequest, AsWeakPtr(),
+        src_subrect, output_size, callback, preferred_color_type))));
+    return;
+  }
+
+  SubmitSurfaceCopyRequest(src_subrect, output_size, callback,
+                           preferred_color_type);
+}
+
+void RenderWidgetHostViewChildFrame::SubmitSurfaceCopyRequest(
+    const gfx::Rect& src_subrect,
+    const gfx::Size& output_size,
+    const ReadbackRequestCallback& callback,
+    const SkColorType preferred_color_type) {
+  DCHECK(IsSurfaceAvailableForCopy());
+
+  scoped_ptr<cc::CopyOutputRequest> request =
+      cc::CopyOutputRequest::CreateRequest(
+          base::Bind(&CopyFromCompositingSurfaceHasResult, output_size,
+                     preferred_color_type, callback));
+  if (!src_subrect.IsEmpty())
+    request->set_area(src_subrect);
+
+  surface_factory_->RequestCopyOfSurface(surface_id_, std::move(request));
 }
 
 void RenderWidgetHostViewChildFrame::CopyFromCompositingSurfaceToVideoFrame(
     const gfx::Rect& src_subrect,
     const scoped_refptr<media::VideoFrame>& target,
     const base::Callback<void(const gfx::Rect&, bool)>& callback) {
   NOTIMPLEMENTED();
   callback.Run(gfx::Rect(), false);
 }
 
@@ skipping 53 matching lines @@
 #endif
 }
 
 void RenderWidgetHostViewChildFrame::ClearCompositorSurfaceIfNecessary() {
   if (surface_factory_ && !surface_id_.is_null())
     surface_factory_->Destroy(surface_id_);
   surface_id_ = cc::SurfaceId();
 }
 
 }  // namespace content