Stretching NativeViewHost, and misc tab capture fixes.

content/browser/renderer_host/delegated_frame_host.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/renderer_host/delegated_frame_host.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 148 matching lines @@
   if (!CanCopyToVideoFrame()) {
     callback.Run(gfx::Rect(), false);
     return;
   }
 
   std::unique_ptr<cc::CopyOutputRequest> request =
       cc::CopyOutputRequest::CreateRequest(base::Bind(
           &DelegatedFrameHost::CopyFromCompositingSurfaceHasResultForVideo,
           AsWeakPtr(),  // For caching the ReadbackYUVInterface on this class.
           nullptr, target, callback));
-  request->set_area(src_subrect);
+  if (!src_subrect.IsEmpty())
+    request->set_area(src_subrect);
   RequestCopyOfOutput(std::move(request));
 }
 
 bool DelegatedFrameHost::CanCopyToBitmap() const {
   return compositor_ &&
          client_->DelegatedFrameHostGetLayer()->has_external_content();
 }
 
 bool DelegatedFrameHost::CanCopyToVideoFrame() const {
   return compositor_ &&
@@ skipping 112 matching lines @@
   if (current_frame_size_in_dip_.height() <
       client_->DelegatedFrameHostDesiredSizeInDIP().height()) {
     bottom_gutter_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR));
     bottom_gutter_->SetColor(GetGutterColor());
     int width = current_frame_size_in_dip_.width();
     int height = client_->DelegatedFrameHostDesiredSizeInDIP().height() -
                  current_frame_size_in_dip_.height();
     bottom_gutter_->SetBounds(
         gfx::Rect(0, current_frame_size_in_dip_.height(), width, height));
     client_->DelegatedFrameHostGetLayer()->Add(bottom_gutter_.get());
-
   } else {
     bottom_gutter_.reset();
   }
 }
 
 gfx::Size DelegatedFrameHost::GetRequestedRendererSize() const {
   if (resize_lock_)
     return resize_lock_->expected_size();
   else
     return client_->DelegatedFrameHostDesiredSizeInDIP();
@@ skipping 51 matching lines @@
   // DelegatedFrameHost (e.g., a call to CopyFromCompositingSurface() for
   // screenshots) since those copy requests do not specify |frame_subscriber()|
   // as a source.
   request->set_source(frame_subscriber()->GetSourceIdForCopyRequest());
   if (subscriber_texture.get()) {
     request->SetTextureMailbox(cc::TextureMailbox(
         subscriber_texture->mailbox(), subscriber_texture->sync_token(),
         subscriber_texture->target()));
   }
 
-  if (local_surface_id_.is_valid()) {
-    // To avoid unnecessary composites, go directly to the Surface rather than
-    // through RequestCopyOfOutput (which goes through the browser
-    // compositor).
-    if (!request_copy_of_output_callback_for_testing_.is_null())
-      request_copy_of_output_callback_for_testing_.Run(std::move(request));
-    else
-      surface_factory_->RequestCopyOfSurface(std::move(request));
-  } else {
-    request->set_area(gfx::Rect(current_frame_size_in_dip_));
-    RequestCopyOfOutput(std::move(request));
-  }
+  RequestCopyOfOutput(std::move(request));
 }
 
 void DelegatedFrameHost::SwapDelegatedFrame(uint32_t compositor_frame_sink_id,
                                             cc::CompositorFrame frame) {
 #if defined(OS_CHROMEOS)
   DCHECK(!resize_lock_ || !client_->IsAutoResizeEnabled());
 #endif
   float frame_device_scale_factor = frame.metadata.device_scale_factor;
 
   DCHECK(!frame.render_pass_list.empty());
@@ skipping 318 matching lines @@
     // with too much entropy (which can drastically increase CPU utilization).
     // When up-scaling, always use "best" because the quality improvement is
     // huge with insignificant performance penalty.  Note that this strategy
     // differs from single-frame snapshot capture.
     display_compositor::GLHelper::ScalerQuality quality =
         ((result_rect.size().width() < region_in_frame.size().width()) &&
          (result_rect.size().height() < region_in_frame.size().height()))
             ? display_compositor::GLHelper::SCALER_QUALITY_BEST
             : display_compositor::GLHelper::SCALER_QUALITY_FAST;
 
+    DVLOG(1) << "Re-creating YUV readback pipeline for source rect "
+             << result_rect.ToString() << " and destination size "
+             << region_in_frame.size().ToString();
+
     dfh->yuv_readback_pipeline_.reset(gl_helper->CreateReadbackPipelineYUV(
         quality, result_rect.size(), result_rect, region_in_frame.size(), true,
         true));
     yuv_readback_pipeline = dfh->yuv_readback_pipeline_.get();
   }
 
   ignore_result(scoped_callback_runner.Release());
   ignore_result(scoped_return_subscriber_texture.Release());
 
   base::Callback<void(bool result)> finished_callback = base::Bind(
@@ skipping 122 matching lines @@
 
 void DelegatedFrameHost::LockResources() {
   DCHECK(local_surface_id_.is_valid());
   delegated_frame_evictor_->LockFrame();
 }
 
 void DelegatedFrameHost::RequestCopyOfOutput(
     std::unique_ptr<cc::CopyOutputRequest> request) {
   if (!request_copy_of_output_callback_for_testing_.is_null()) {
     request_copy_of_output_callback_for_testing_.Run(std::move(request));
+    return;
+  }
+
+  // If a specific area has not been requested, set one to ensure correct
+  // clipping occurs.
+  if (!request->has_area())
+    request->set_area(gfx::Rect(current_frame_size_in_dip_));
+
+  // To avoid unnecessary browser composites, try to go directly to the Surface
+  // rather than through the Layer.
+  if (local_surface_id_.is_valid()) {
+    // Surfaces interpret the request area in terms of their own coordinate
+    // system, so adjust by the scale factor, if necessary.
+    if (current_scale_factor_ != 1.0) {
+      request->set_area(gfx::ScaleToEnclosingRect(
+          request->area(), current_scale_factor_, current_scale_factor_));
+    }
+    surface_factory_->RequestCopyOfSurface(std::move(request));
   } else {
     client_->DelegatedFrameHostGetLayer()->RequestCopyOfOutput(
         std::move(request));
   }
 }
 
 void DelegatedFrameHost::UnlockResources() {
   DCHECK(local_surface_id_.is_valid());
   delegated_frame_evictor_->UnlockFrame();
 }
 
 }  // namespace content