Support copying a partial rectangle region from the compositing surface on Win.

ui/surface/accelerated_surface_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_win.h"
 
 #include <windows.h>
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/scoped_native_library.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
 #include "base/tracked_objects.h"
 #include "base/win/wrapped_window_proc.h"
 #include "ui/base/win/hwnd_util.h"
+#include "ui/gfx/rect.h"
 #include "ui/gl/gl_switches.h"
 
 namespace {
 
 typedef HRESULT (WINAPI *Direct3DCreate9ExFunc)(UINT sdk_version,
                                                 IDirect3D9Ex **d3d);
 
 const wchar_t kD3D9ModuleName[] = L"d3d9.dll";
 const char kCreate3D9DeviceExName[] = "Direct3DCreate9Ex";
 
@@ skipping 72 matching lines @@
   D3DDECL_END()
 };
 
 UINT GetPresentationInterval() {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableGpuVsync))
     return D3DPRESENT_INTERVAL_IMMEDIATE;
   else
     return D3DPRESENT_INTERVAL_ONE;
 }
 
-// Calculate the number necessary to transform |source_size| into |dest_size|
-// by repeating downsampling of the image of |source_size| by a factor no more
+// 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::Size& source_size, const gfx::Size& dest_size) {
+int GetResampleCount(const gfx::Rect& src_subrect,
+                     const gfx::Size& dst_size,
+                     const gfx::Size& back_buffer_size) {
+  if (src_subrect.size() == dst_size) {
+    // Even when the size of |src_subrect| is equal to |dst_size|, it is
+    // necessary to resample pixels at least once unless |src_subrect| exactly
+    // covers the back buffer.
+    return (src_subrect == gfx::Rect(back_buffer_size)) ? 0 : 1;
+  }
   int width_count = 0;
-  int width = source_size.width();
-  while (width > dest_size.width()) {
+  int width = src_subrect.width();
+  while (width > dst_size.width()) {
     ++width_count;
     width >>= 1;
   }
   int height_count = 0;
-  int height = source_size.height();
-  while (height > dest_size.height()) {
+  int height = src_subrect.height();
+  while (height > dst_size.height()) {
     ++height_count;
     height >>= 1;
   }
   return std::max(width_count, height_count);
 }
 
 // Returns half the size of |size| no smaller than |min_size|.
 gfx::Size GetHalfSizeNoLessThan(const gfx::Size& size,
                                 const gfx::Size& min_size) {
   return gfx::Size(std::max(min_size.width(), size.width() / 2),
@@ skipping 356 matching lines @@
                               D3DPRESENT_INTERVAL_IMMEDIATE);
     // For latency_tests.cc:
     UNSHIPPED_TRACE_EVENT_INSTANT0("test_gpu", "CompositorSwapBuffersComplete");
     if (FAILED(hr))
       return false;
   }
 
   return true;
 }
 
-bool AcceleratedPresenter::CopyTo(const gfx::Size& size, void* buf) {
+bool AcceleratedPresenter::CopyTo(const gfx::Rect& src_subrect,
+                                  const gfx::Size& dst_size,
+                                  void* buf) {
   base::AutoLock locked(lock_);
 
   if (!swap_chain_)
     return false;
 
   base::win::ScopedComPtr<IDirect3DSurface9> back_buffer;
   HRESULT hr = swap_chain_->GetBackBuffer(0,
                                           D3DBACKBUFFER_TYPE_MONO,
                                           back_buffer.Receive());
   if (FAILED(hr))
     return false;
 
   D3DSURFACE_DESC desc;
   hr = back_buffer->GetDesc(&desc);
   if (FAILED(hr))
     return false;
 
   const gfx::Size back_buffer_size(desc.Width, desc.Height);
   if (back_buffer_size.IsEmpty())
     return false;
 
   // Set up intermediate buffers needed for downsampling.
   const int resample_count =
-      GetResampleCount(gfx::Size(desc.Width, desc.Height), size);
+      GetResampleCount(src_subrect, dst_size, back_buffer_size);
   base::win::ScopedComPtr<IDirect3DSurface9> final_surface;
   base::win::ScopedComPtr<IDirect3DSurface9> temp_buffer[2];
   if (resample_count == 0)
     final_surface = back_buffer;
   if (resample_count > 0) {
     if (!CreateTemporarySurface(present_thread_->device(),
-                                size,
+                                dst_size,
                                 final_surface.Receive()))
       return false;
   }
-  const gfx::Size half_size = GetHalfSizeNoLessThan(back_buffer_size, size);
+  const gfx::Size half_size =
+      GetHalfSizeNoLessThan(src_subrect.size(), dst_size);
   if (resample_count > 1) {
     if (!CreateTemporarySurface(present_thread_->device(),
                                 half_size,
                                 temp_buffer[0].Receive()))
       return false;
   }
   if (resample_count > 2) {
-    const gfx::Size quarter_size = GetHalfSizeNoLessThan(half_size, size);
+    const gfx::Size quarter_size = GetHalfSizeNoLessThan(half_size, dst_size);
     if (!CreateTemporarySurface(present_thread_->device(),
                                 quarter_size,
                                 temp_buffer[1].Receive()))
       return false;
   }
 
+
   // Repeat downsampling the surface until its size becomes identical to
-  // |size|. We keep the factor of each downsampling no more than two because
-  // using a factor more than two can introduce aliasing.
-  gfx::Size read_size = back_buffer_size;
+  // |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) {
     base::win::ScopedComPtr<IDirect3DSurface9> read_buffer =
         (i == 0) ? back_buffer : temp_buffer[read_buffer_index];
     base::win::ScopedComPtr<IDirect3DSurface9> write_buffer =
         (i == resample_count - 1) ? final_surface :
                                     temp_buffer[write_buffer_index];
-    RECT read_rect = {0, 0, read_size.width(), read_size.height()};
-    RECT write_rect = {0, 0, write_size.width(), write_size.height()};
+    RECT write_rect = gfx::Rect(write_size).ToRECT();
     hr = present_thread_->device()->StretchRect(read_buffer,
                                                 &read_rect,
                                                 write_buffer,
                                                 &write_rect,
                                                 D3DTEXF_LINEAR);
     if (FAILED(hr))
       return false;
-    read_size = write_size;
-    write_size = GetHalfSizeNoLessThan(write_size, size);
+    read_rect = write_rect;
+    write_size = GetHalfSizeNoLessThan(write_size, dst_size);
     std::swap(read_buffer_index, write_buffer_index);
   }
 
-  DCHECK(size == read_size);
-
   base::win::ScopedComPtr<IDirect3DSurface9> temp_surface;
   HANDLE handle = reinterpret_cast<HANDLE>(buf);
   hr =  present_thread_->device()->CreateOffscreenPlainSurface(
-    size.width(),
-    size.height(),
+    dst_size.width(),
+    dst_size.height(),
     D3DFMT_A8R8G8B8,
     D3DPOOL_SYSTEMMEM,
     temp_surface.Receive(),
     &handle);
   if (FAILED(hr))
     return false;
 
   // Copy the data in the temporary buffer to the surface backed by |buf|.
   hr = present_thread_->device()->GetRenderTargetData(final_surface,
                                                       temp_surface);
@@ skipping 237 matching lines @@
 
 AcceleratedSurface::~AcceleratedSurface() {
   g_accelerated_presenter_map.Pointer()->RemovePresenter(presenter_);
   presenter_->Invalidate();
 }
 
 bool AcceleratedSurface::Present(HDC dc) {
   return presenter_->Present(dc);
 }
 
-bool AcceleratedSurface::CopyTo(const gfx::Size& size, void* buf) {
-  return presenter_->CopyTo(size, buf);
+bool AcceleratedSurface::CopyTo(const gfx::Rect& src_subrect,
+                                const gfx::Size& dst_size,
+                                void* buf) {
+  return presenter_->CopyTo(src_subrect, dst_size, buf);
 }
 
 void AcceleratedSurface::Suspend() {
   presenter_->Suspend();
 }
 
 void AcceleratedSurface::WasHidden() {
   presenter_->WasHidden();
 }