Support browser side thumbnailing for GPU composited pages on Windows.

ui/gfx/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/gfx/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"
@@ skipping 120 matching lines @@
       device_.Receive());
   if (FAILED(hr))
     return;
 
   hr = device_->CreateQuery(D3DQUERYTYPE_EVENT, query_.Receive());
   if (FAILED(hr)) {
     device_ = NULL;
   }
 }
 
+bool AcceleratedPresenter::CopyTo(const gfx::Size& size,
+                                  std::vector<unsigned char>* buf) {
+  base::AutoLock locked(lock_);
+
+  base::win::ScopedComPtr<IDirect3DSurface9> temp_buffer[2];
+  HRESULT hr = swap_chain_->GetBackBuffer(0,

[apatrick_chromium, 2012/03/08 20:15:47]

swap_chain_ will be null if either no surface has been presented yet or the
surface has been suspended because it has not been visible for some number of
tab switches. I think just return false if swap_chain_ is null. Check whether it
is null after locking lock_ though because it is suspended on the present
thread.

[mazda, 2012/03/10 07:51:37]

Done.

+                                          D3DBACKBUFFER_TYPE_MONO,
+                                          temp_buffer[0].Receive());
+  if (FAILED(hr))
+    return false;
+
+  D3DSURFACE_DESC desc;
+  hr = temp_buffer[0]->GetDesc(&desc);
+  if (FAILED(hr) || (desc.Width == 0) || (desc.Height == 0))
+    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.
+  int buffer_width = desc.Width;
+  int buffer_height = desc.Height;
+  int read_buffer = 0;
+  int write_buffer = 1;
+  do {

[apatrick_chromium, 2012/03/08 20:15:47]

I believe it is possible to call GetRenderTargetData directly on a swap chain
surface since a swap chain surface is a render target. Therefore I think this
loop should iterate zero times if the swap chain happens to be exactly the
requested size.

[mazda, 2012/03/10 07:51:37]

Done.

+    buffer_width = std::max(buffer_width / 2, size.width());
+    buffer_height = std::max(buffer_height / 2, size.height());
+    temp_buffer[write_buffer].Release();
+    hr = present_thread_->device()->CreateRenderTarget(

[vangelis, 2012/03/08 17:34:35]

Can we avoid creating render targets for all intermediate resolutions? 
StretchRect takes a source and dest rect so it should in theory be possible to
do it. I suspect that we'll need one surface that's half the size of the buffer
and one that's at the target resulution (for the final GetRenderTargetData)  

[mazda, 2012/03/10 07:51:37]

Done.

+        buffer_width,
+        buffer_height,
+        D3DFMT_A8R8G8B8,
+        D3DMULTISAMPLE_NONE,
+        0,
+        TRUE,
+        temp_buffer[write_buffer].Receive(),
+        NULL);
+    if (FAILED(hr))
+      return false;
+
+    hr = present_thread_->device()->StretchRect(temp_buffer[read_buffer],
+                                                NULL,
+                                                temp_buffer[write_buffer],
+                                                NULL,
+                                                D3DTEXF_LINEAR);
+    if (FAILED(hr))
+      return false;
+
+    std::swap(read_buffer, write_buffer);
+  } while (size != gfx::Size(buffer_width, buffer_height));
+
+  const size_t buf_size = static_cast<size_t>(4 * size.GetArea());
+  if (buf->size() < buf_size) {
+    buf->resize(buf_size);
+  }
+
+  base::win::ScopedComPtr<IDirect3DSurface9> temp_surface;
+  HANDLE handle = reinterpret_cast<HANDLE>(&(*buf)[0]);
+  hr =  present_thread_->device()->CreateOffscreenPlainSurface(
+    size.width(),
+    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(
+      temp_buffer[read_buffer], temp_surface);
+  if (FAILED(hr))
+    return false;
+
+  return true;
+}
+
 void PresentThread::Init() {
   TRACE_EVENT0("surface", "PresentThread::Init");
   d3d_module_.Reset(base::LoadNativeLibrary(FilePath(kD3D9ModuleName), NULL));
   ResetDevice();
 }
 
 void PresentThread::CleanUp() {
   // The D3D device and query are leaked because destroying the associated D3D
   // query crashes some Intel drivers.
   device_.Detach();
@@ skipping 266 matching lines @@
                                          completion_task);
 }
 
 bool AcceleratedSurface::Present(HWND window) {
   if (presenter_)
     return presenter_->Present(window);
   else
     return false;
 }
 
+bool AcceleratedSurface::CopyTo(const gfx::Size& size,
+                                std::vector<unsigned char>* buf) {
+  return presenter_->CopyTo(size, buf);
+}
+
 void AcceleratedSurface::Suspend() {
   if (presenter_)
     presenter_->Suspend();
 }
-