Tab Capture: Backing store readbacks to YV12 VideoFrames.

ui/surface/accelerated_surface_transformer_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 "ui/surface/accelerated_surface_transformer_win.h"
 
 #include <vector>
 
 #include "accelerated_surface_transformer_win_hlsl_compiled.h"
 #include "base/debug/trace_event.h"
@@ skipping 51 matching lines @@
  private:
   ScopedComPtr<IDirect3DDevice9> device_;
   int target_id_;
   ScopedComPtr<IDirect3DSurface9> original_render_target_;
 };
 
 // Calculate the number necessary to transform |src_subrect| into |dst_size|
 // by repeating downsampling of the image of |src_subrect| by a factor no more
 // than 2.
 int GetResampleCount(const gfx::Rect& src_subrect,
-                     const gfx::Size& dst_size,
-                     const gfx::Size& back_buffer_size) {
+                     const gfx::Size& dst_size) {
   // At least one copy is required, since the back buffer itself is not
   // lockable.
   int min_resample_count = 1;
   int width_count = 0;
   int width = src_subrect.width();
   while (width > dst_size.width()) {
     ++width_count;
     width >>= 1;
   }
   int height_count = 0;
@@ skipping 228 matching lines @@
                             vertices,
                             sizeof(vertices[0]));
   device()->EndScene();
 
 }
 
 // Resize an RGB surface using repeated linear interpolation.
 bool AcceleratedSurfaceTransformer::ResizeBilinear(
     IDirect3DSurface9* src_surface,
     const gfx::Rect& src_subrect,
-    IDirect3DSurface9* dst_surface) {
-  gfx::Size src_size = d3d_utils::GetSize(src_surface);
-  gfx::Size dst_size = d3d_utils::GetSize(dst_surface);
+    IDirect3DSurface9* dst_surface,
+    const gfx::Rect& dst_rect) {
+  gfx::Size src_size = src_subrect.size();
+  gfx::Size dst_size = dst_rect.size();
 
   if (src_size.IsEmpty() || dst_size.IsEmpty())
     return false;
 
   HRESULT hr = S_OK;
   // Set up intermediate buffers needed for downsampling.
-  const int resample_count =
-      GetResampleCount(src_subrect, dst_size, src_size);
+  const int resample_count = GetResampleCount(src_subrect, dst_size);
   base::win::ScopedComPtr<IDirect3DSurface9> temp_buffer[2];
   const gfx::Size half_size =
       GetHalfSizeNoLessThan(src_subrect.size(), dst_size);
   if (resample_count > 1) {
     TRACE_EVENT0("gpu", "CreateTemporarySurface");
     if (!d3d_utils::CreateTemporaryLockableSurface(device(),
                                                    half_size,
                                                    temp_buffer[0].Receive()))
       return false;
   }
@@ skipping 10 matching lines @@
   // |dst_size|. We keep the factor of each downsampling no more than two
   // because using a factor more than two can introduce aliasing.
   RECT read_rect = src_subrect.ToRECT();
   gfx::Size write_size = half_size;
   int read_buffer_index = 1;
   int write_buffer_index = 0;
   for (int i = 0; i < resample_count; ++i) {
     TRACE_EVENT0("gpu", "StretchRect");
     IDirect3DSurface9* read_buffer =
         (i == 0) ? src_surface : temp_buffer[read_buffer_index];
-    IDirect3DSurface9* write_buffer =
-        (i == resample_count - 1) ? dst_surface :
-                                    temp_buffer[write_buffer_index];
-    RECT write_rect = gfx::Rect(write_size).ToRECT();
+    IDirect3DSurface9* write_buffer;
+    RECT write_rect;
+    if (i == resample_count - 1) {
+      write_buffer = dst_surface;
+      write_rect = dst_rect.ToRECT();
+    } else {
+      write_buffer = temp_buffer[write_buffer_index];
+      write_rect = gfx::Rect(write_size).ToRECT();
+    }
+
     hr = device()->StretchRect(read_buffer,
                                &read_rect,
                                write_buffer,
                                &write_rect,
                                D3DTEXF_LINEAR);
 
     if (FAILED(hr))
       return false;
     read_rect = write_rect;
     write_size = GetHalfSizeNoLessThan(write_size, dst_size);
@@ skipping 210 matching lines @@
     return false;
 
   HRESULT hr = device()->SetVertexShader(vertex_shaders_[combo]);
   if (!SUCCEEDED(hr))
     return false;
   hr = device()->SetPixelShader(pixel_shaders_[combo]);
   if (!SUCCEEDED(hr))
     return false;
   return true;
 }