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 <d3d9.h>
 #include <windows.h>
 
 #include <list>
@@ skipping 89 matching lines @@
   AcceleratedPresenter();
   ~AcceleratedPresenter();
 
   void AsyncPresentAndAcknowledge(gfx::NativeWindow window,
                                   const gfx::Size& size,
                                   int64 surface_id,
                                   const base::Closure& completion_task);
 
   bool Present(gfx::NativeWindow window);
 
+  bool CopyTo(const gfx::Size& size, std::vector<unsigned char>* buf);
+
   void Suspend();
 
  private:
   void DoInitialize();
   void DoResize(const gfx::Size& size);
   void DoReset();
   void DoPresentAndAcknowledge(gfx::NativeWindow window,
                                const gfx::Size& size,
                                int64 surface_id,
                                const base::Closure& completion_task);
@@ skipping 136 matching lines @@
       hr = query_->GetData(NULL, 0, D3DGETDATA_FLUSH);
 
       if (hr == S_FALSE)
         Sleep(0);
     } while (hr == S_FALSE);
   }
 
   return true;
 }
 
+bool AcceleratedPresenter::CopyTo(const gfx::Size& size,
+                                  std::vector<unsigned char>* buf) {
+  base::win::ScopedComPtr<IDirect3DSurface9> render_target;

[apatrick_chromium, 2012/03/07 20:39:37]

Make the first line of this function:
base::AutoLock locked(lock_);

Otherwise it might try to access the surface concurrently with a present thread.

[mazda, 2012/03/08 13:14:28]

Done.

+  HRESULT hr = device_->GetRenderTarget(0, render_target.Receive());

[apatrick_chromium, 2012/03/07 20:39:37]

I just changed this unfortunately but you should be able to call GetBackBuffer
on the newly added swap_chain_ with the same effect.

[mazda, 2012/03/08 13:14:28]

Done.

+  if (FAILED(hr))
+    return false;
+
+  base::win::ScopedComPtr<IDirect3DSurface9> temp_render_target;
+  hr = device_->CreateRenderTarget(
+      size.width(),
+      size.height(),
+      D3DFMT_A8R8G8B8,
+      D3DMULTISAMPLE_NONE,
+      0,
+      TRUE,
+      temp_render_target.Receive(),
+      NULL);
+  if (FAILED(hr))
+    return false;
+
+  // Copy the render target to a temporary render target first because
+  // IDirect3DDevice9::StretchRect does not support copying to the surface in
+  // the system memory.
+  hr = device_->StretchRect(render_target, NULL, temp_render_target, NULL,

[apatrick_chromium, 2012/03/07 20:39:37]

If the downsampling reduces the size by more than half on either axis, this will
introduce aliasing. The solution would be to call this multiple times, each by a
factor of no more than two.

[mazda, 2012/03/08 13:14:28]

Done.

+                            D3DTEXF_LINEAR);
+  if (FAILED(hr))
+    return false;
+
+  base::win::ScopedComPtr<IDirect3DSurface9> temp_surface;
+  hr = device_->CreateOffscreenPlainSurface(
+      size.width(),
+      size.height(),
+      D3DFMT_A8R8G8B8,
+      D3DPOOL_SYSTEMMEM,
+      temp_surface.Receive(),
+      NULL);

[apatrick_chromium, 2012/03/07 20:39:37]

HANDLE handle = reinterpret_cast<HANDLE>(&buf[0]);  // but fix the buf[0] issue
for zero area buffers
hr = device_->CreateOffscreenPlainSurface(
    size.width(),
    size.height(),
    D3DFMT_A8R8G8B8,
    D3DPOOL_SYSTEMMEM,
    temp_surface.Receive(),
    &handle);

Will create an offscreen system memory surface backed by the bits in buf...

[mazda, 2012/03/08 13:14:28]

Thanks. This is much simpler and cleaner.

+  if (FAILED(hr))
+    return false;
+
+  // Then copy the data in the temporary render target to a temporary surface
+  // in the system memory that is used for the final copy to |buf|.
+  hr = device_->GetRenderTargetData(temp_render_target, temp_surface);
+  if (FAILED(hr))
+    return false;
+
+  const size_t buf_size = static_cast<size_t>(4 * size.GetArea());
+  if (buf->size() < buf_size) {
+    buf->resize(buf_size);
+  }
+
+  D3DLOCKED_RECT locked_rect;

[apatrick_chromium, 2012/03/07 20:39:37]

... thereby eliminating the need for lines 318 through 330 and lots of redundant
memory copies. See
http://msdn.microsoft.com/en-us/library/windows/desktop/bb219800(v=vs.85).asp...
(Texture Creation in System Memory).

[mazda, 2012/03/08 13:14:28]

Done.

+  const int kLockFlags = D3DLOCK_READONLY | D3DLOCK_NO_DIRTY_UPDATE |
+                         D3DLOCK_NOOVERWRITE;
+  temp_surface->LockRect(&locked_rect, NULL, kLockFlags);

[apatrick_chromium, 2012/03/07 20:39:37]

If these lines remain, I would not assume LockRect always succeeds and returns a
value locked_rect.pBits. The device might be lost.

[mazda, 2012/03/08 13:14:28]

I deleted this code block following your comment above.

+  const int kBytesPerRow = 4 * size.width();
+  for (int y = 0; y < size.height(); ++y) {
+    unsigned char* p1 =
+        static_cast<unsigned char*>(locked_rect.pBits) + locked_rect.Pitch * y;
+    unsigned char* p2 =
+        static_cast<unsigned char*>(&(*buf)[0]) + kBytesPerRow * y;
+    memcpy(p2, p1, kBytesPerRow);
+  }
+  temp_surface->UnlockRect();
+
+  return true;
+}
+
 void AcceleratedPresenter::Suspend() {
   // Resize the swap chain to 1 x 1 to save memory while the presenter is not
   // in use.
   pending_size_ = gfx::Size(1, 1);
   base::AtomicRefCountInc(&num_pending_resizes_);
 
   g_present_thread_pool.Pointer()->PostTask(
       thread_affinity_,
       FROM_HERE,
       base::Bind(&AcceleratedPresenter::DoResize,
@@ skipping 229 matching lines @@
   presenter_->AsyncPresentAndAcknowledge(window,
                                          size,
                                          surface_id,
                                          completion_task);
 }
 
 bool AcceleratedSurface::Present(HWND window) {
   return presenter_->Present(window);
 }
 
+bool AcceleratedSurface::CopyTo(const gfx::Size& size,
+                                std::vector<unsigned char>* buf) {
+  return presenter_->CopyTo(size, buf);
+}
+
 void AcceleratedSurface::Suspend() {
   presenter_->Suspend();
 }
-