Add IPC allowing GPU process to tell browser process to temporarily drop a front buffer.

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 104 matching lines @@
   void DoReset();
   void DoPresentAndAcknowledge(gfx::NativeWindow window,
                                const gfx::Size& size,
                                int64 surface_id,
                                const base::Closure& completion_task);
 
   // Immutable and accessible from any thread without the lock.
   const int thread_affinity_;
   base::ScopedNativeLibrary d3d_module_;
 
+  // Whether the presenter is suspended and therefore unable to represent. Only
+  // accessed on the UI thread so the lock is unnecessary.
+  bool suspended_;
+
   // The size of the swap chain once any pending resizes have been processed.
   // Only accessed on the UI thread so the lock is unnecessary.
   gfx::Size pending_size_;
 
   // The current size of the swap chain. This is only accessed on the thread
   // with which the surface has affinity.
   gfx::Size size_;
 
   // The number of pending resizes. This is accessed with atomic operations so
   // the lock is not necessary.
   base::AtomicRefCount num_pending_resizes_;
 
   // Take the lock before accessing any other state.
   base::Lock lock_;
 
   // This device's swap chain is presented to the child window. Copy semantics
   // are used so it is possible to represent it to quickly validate the window.
   base::win::ScopedComPtr<IDirect3DDevice9Ex> device_;
 
   // This query is used to wait until a certain amount of progress has been
   // made by the GPU and it is safe for the producer to modify its shared
   // texture again.
   base::win::ScopedComPtr<IDirect3DQuery9> query_;
 
   DISALLOW_COPY_AND_ASSIGN(AcceleratedPresenter);
 };
 
 AcceleratedPresenter::AcceleratedPresenter()
     : thread_affinity_(g_present_thread_pool.Pointer()->NextThread()),
+      suspended_(true),
       num_pending_resizes_(0) {
   g_present_thread_pool.Pointer()->PostTask(
       thread_affinity_,
       FROM_HERE,
       base::Bind(&AcceleratedPresenter::DoInitialize, base::Unretained(this)));
 }
 
 AcceleratedPresenter::~AcceleratedPresenter() {
   // The D3D device and query are leaked because destroying the associated D3D
   // query crashes some Intel drivers.
@@ skipping 25 matching lines @@
 
   g_present_thread_pool.Pointer()->PostTask(
       thread_affinity_,
       FROM_HERE,
       base::Bind(&AcceleratedPresenter::DoPresentAndAcknowledge,
                  base::Unretained(this),
                  window,
                  size,
                  surface_id,
                  completion_task));
+
+  suspended_ = false;
 }
 
 bool AcceleratedPresenter::Present(gfx::NativeWindow window) {
   TRACE_EVENT0("surface", "Present");
 
   HRESULT hr;
 
+  if (suspended_)
+    return false;
+
   base::AutoLock locked(lock_);
 
   if (!device_)
     return true;
 
   RECT rect;
   if (!GetClientRect(window, &rect))
     return true;
 
   {
@@ skipping 42 matching lines @@
   // 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,
                  base::Unretained(this),
                  gfx::Size(1, 1)));
+
+  suspended_ = true;
 }
 
 void AcceleratedPresenter::DoInitialize() {
   TRACE_EVENT0("surface", "DoInitialize");
 
   HRESULT hr;
 
   d3d_module_.Reset(base::LoadNativeLibrary(FilePath(kD3D9ModuleName), NULL));
 
   Direct3DCreate9ExFunc create_func = reinterpret_cast<Direct3DCreate9ExFunc>(
@@ skipping 214 matching lines @@
     const base::Closure& completion_task) {
   presenter_->AsyncPresentAndAcknowledge(window,
                                          size,
                                          surface_id,
                                          completion_task);
 }
 
 bool AcceleratedSurface::Present(HWND window) {
   return presenter_->Present(window);
 }
+
+void AcceleratedSurface::Suspend() {
+  presenter_->Suspend();
+}
+