Win AcceleratedSurface no longer polls queries on separate thread.

ui/gfx/surface/accelerated_surface_win.cc

 // Copyright (c) 2011 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 <list>
 
 #include "base/bind.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/memory/weak_ptr.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/tracked_objects.h"
 #include "base/win/wrapped_window_proc.h"
 #include "ipc/ipc_message.h"
 #include "ui/base/win/hwnd_util.h"
 #include "ui/gfx/gl/gl_switches.h"
 
-#pragma comment(lib, "d3d9.lib")
-
 namespace {
 
 typedef HRESULT (WINAPI *Direct3DCreate9ExFunc)(UINT sdk_version,
                                                 IDirect3D9Ex **d3d);
 
-const int64 kPollQueryInterval = 1;
-
 const wchar_t kD3D9ModuleName[] = L"d3d9.dll";
 const char kCreate3D9DeviceExName[] = "Direct3DCreate9Ex";
 
-class QuerySyncThread
-    : public base::Thread,
-      public base::RefCounted<QuerySyncThread> {
- public:
-  explicit QuerySyncThread(const char* name);
-  virtual ~QuerySyncThread();
-
-  // Invoke the completion task when the query completes.
-  void AcknowledgeQuery(const base::win::ScopedComPtr<IDirect3DQuery9>& query,
-                        const base::Closure& completion_task);
-
-  // Acknowledge all pending queries for the given device early then invoke
-  // the given task.
-  void AcknowledgeEarly(
-      const base::win::ScopedComPtr<IDirect3DDevice9Ex>& device,
-      const base::Closure& completion_task);
-
- private:
-  void PollQueries();
-
-  struct PendingQuery {
-    base::win::ScopedComPtr<IDirect3DQuery9> query;
-    base::Closure completion_task;
-  };
-
-  typedef std::list<PendingQuery> PendingQueries;
-  PendingQueries pending_queries_;
-  base::WeakPtrFactory<QuerySyncThread> poll_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(QuerySyncThread);
-};
-
 class PresentThreadPool {
  public:
   static const int kNumPresentThreads = 4;
 
   PresentThreadPool();
 
   int NextThread();
 
   void PostTask(int thread,
                 const tracked_objects::Location& from_here,
                 const base::Closure& task);
 
-  void AcknowledgeQuery(const tracked_objects::Location& from_here,
-                        const base::win::ScopedComPtr<IDirect3DQuery9>& query,
-                        const base::Closure& completion_task);
-
-  void AcknowledgeEarly(
-      const tracked_objects::Location& from_here,
-      const base::win::ScopedComPtr<IDirect3DDevice9Ex>& device,
-      const base::Closure& completion_task);
-
  private:
   int next_thread_;
   scoped_ptr<base::Thread> present_threads_[kNumPresentThreads];
-  scoped_refptr<QuerySyncThread> query_sync_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(PresentThreadPool);
 };
 
 base::LazyInstance<PresentThreadPool>
     g_present_thread_pool = LAZY_INSTANCE_INITIALIZER;
 
-QuerySyncThread::QuerySyncThread(const char* name)
-    : base::Thread(name),
-      poll_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
-}
-
-QuerySyncThread::~QuerySyncThread() {
-}
-
-void QuerySyncThread::AcknowledgeQuery(
-    const base::win::ScopedComPtr<IDirect3DQuery9>& query,
-    const base::Closure& completion_task) {
-  PendingQuery pending_query;
-  pending_query.query = query;
-  pending_query.completion_task = completion_task;
-  pending_queries_.push_back(pending_query);
-
-  // Cancel any pending poll tasks. There should only ever be one pending at a
-  // time.
-  poll_factory_.InvalidateWeakPtrs();
-
-  PollQueries();
-}
-
-void QuerySyncThread::AcknowledgeEarly(
-    const base::win::ScopedComPtr<IDirect3DDevice9Ex>& device,
-    const base::Closure& completion_task) {
-  TRACE_EVENT0("surface", "AcknowledgeEarly");
-
-  PendingQueries::iterator it = pending_queries_.begin();
-  while (it != pending_queries_.end()) {
-    const PendingQuery& pending_query = *it;
-
-    base::win::ScopedComPtr<IDirect3DDevice9> query_device;
-    pending_query.query->GetDevice(query_device.Receive());
-
-    base::win::ScopedComPtr<IDirect3DDevice9Ex> query_device_ex;
-    query_device_ex.QueryFrom(query_device.get());
-
-    if (query_device_ex.get() != device.get()) {
-      ++it;
-    } else {
-      pending_query.completion_task.Run();
-      it = pending_queries_.erase(it);
-    }
-  }
-
-  if (!completion_task.is_null())
-    completion_task.Run();
-}
-
-
-void QuerySyncThread::PollQueries() {
-  TRACE_EVENT0("surface", "PollQueries");
-
-  PendingQueries::iterator it = pending_queries_.begin();
-  while (it != pending_queries_.end()) {
-    const PendingQuery& pending_query = *it;
-
-    HRESULT hr = pending_query.query->GetData(NULL, 0, D3DGETDATA_FLUSH);
-    if (hr == S_FALSE) {
-      ++it;
-    } else {
-      pending_query.completion_task.Run();
-      it = pending_queries_.erase(it);
-    }
-  }
-
-  // Try again later if there are incomplete queries. Otherwise don't poll again
-  // until AcknowledgeQuery is called with a new query.
-  if (!pending_queries_.empty()) {
-    message_loop()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&QuerySyncThread::PollQueries, poll_factory_.GetWeakPtr()),
-        kPollQueryInterval);
-  }
-}
-
 PresentThreadPool::PresentThreadPool() : next_thread_(0) {
   for (int i = 0; i < kNumPresentThreads; ++i) {
     present_threads_[i].reset(new base::Thread(
         base::StringPrintf("PresentThread #%d", i).c_str()));
     present_threads_[i]->Start();
   }
-
-  query_sync_thread_ = new QuerySyncThread("QuerySyncThread");
-  query_sync_thread_->Start();
 }
 
 int PresentThreadPool::NextThread() {
   next_thread_ = (next_thread_ + 1) % kNumPresentThreads;
   return next_thread_;
 }
 
 void PresentThreadPool::PostTask(int thread,
                                  const tracked_objects::Location& from_here,
                                  const base::Closure& task) {
   DCHECK_GE(thread, 0);
   DCHECK_LT(thread, kNumPresentThreads);
 
   present_threads_[thread]->message_loop()->PostTask(from_here, task);
 }
 
-void PresentThreadPool::AcknowledgeQuery(
-    const tracked_objects::Location& from_here,
-    const base::win::ScopedComPtr<IDirect3DQuery9>& query,
-    const base::Closure& completion_task) {
-  query_sync_thread_->message_loop()->PostTask(
-      from_here,
-      base::Bind(&QuerySyncThread::AcknowledgeQuery,
-                 query_sync_thread_,
-                 query,
-                 completion_task));
-}
-
-void PresentThreadPool::AcknowledgeEarly(
-    const tracked_objects::Location& from_here,
-    const base::win::ScopedComPtr<IDirect3DDevice9Ex>& device,
-    const base::Closure& completion_task) {
-  query_sync_thread_->message_loop()->PostTask(
-      from_here,
-      base::Bind(&QuerySyncThread::AcknowledgeEarly,
-                 query_sync_thread_,
-                 device,
-                 completion_task));
-}
-
 UINT GetPresentationInterval() {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableGpuVsync))
     return D3DPRESENT_INTERVAL_IMMEDIATE;
   else
     return D3DPRESENT_INTERVAL_ONE;
 }
 
 }  // namespace anonymous
 
 AcceleratedSurface::AcceleratedSurface(HWND parent)
     : thread_affinity_(g_present_thread_pool.Pointer()->NextThread()),
       window_(parent),
       num_pending_resizes_(0) {
 }
 
 AcceleratedSurface::~AcceleratedSurface() {
   // Destroy should have been called prior to the last reference going away.
   DCHECK(!device_);
 }
 
 void AcceleratedSurface::Initialize() {
   g_present_thread_pool.Pointer()->PostTask(
       thread_affinity_,
       FROM_HERE,
       base::Bind(&AcceleratedSurface::DoInitialize, this));
 }
 
 void AcceleratedSurface::Destroy() {
-  g_present_thread_pool.Pointer()->AcknowledgeEarly(
+  g_present_thread_pool.Pointer()->PostTask(
+      thread_affinity_,
       FROM_HERE,
-      device_,
-      base::Bind(&AcceleratedSurface::QueriesDestroyed, this));
+      base::Bind(&AcceleratedSurface::DoDestroy, this));
 }
 
 void AcceleratedSurface::AsyncPresentAndAcknowledge(
     const gfx::Size& size,
     int64 surface_id,
     const base::Closure& completion_task) {
   const int kRound = 64;
   gfx::Size quantized_size(
       std::max(1, (size.width() + kRound - 1) / kRound * kRound),
       std::max(1, (size.height() + kRound - 1) / kRound * kRound));
@@ skipping 59 matching lines @@
         Sleep(0);
     } while (hr == S_FALSE);
   }
 }
 
 void AcceleratedSurface::DoInitialize() {
   TRACE_EVENT0("surface", "DoInitialize");
 
   HRESULT hr;
 
-  HMODULE module = GetModuleHandle(kD3D9ModuleName);
-  if (!module)
-    return;
+  d3d_module_.Reset(base::LoadNativeLibrary(FilePath(kD3D9ModuleName), NULL));
 
   Direct3DCreate9ExFunc create_func = reinterpret_cast<Direct3DCreate9ExFunc>(
-      GetProcAddress(module, kCreate3D9DeviceExName));
+      d3d_module_.GetFunctionPointer(kCreate3D9DeviceExName));
   if (!create_func)
     return;
 
   base::win::ScopedComPtr<IDirect3D9Ex> d3d;
   hr = create_func(D3D_SDK_VERSION, d3d.Receive());
   if (FAILED(hr))
     return;
 
   D3DPRESENT_PARAMETERS parameters = { 0 };
   parameters.BackBufferWidth = 1;
@@ skipping 44 matching lines @@
   query_ = NULL;
 }
 
 void AcceleratedSurface::DoResize(const gfx::Size& size) {
   TRACE_EVENT0("surface", "DoResize");
 
   HRESULT hr;
 
   base::AtomicRefCountDec(&num_pending_resizes_);
 
+  base::AutoLock locked(lock_);
+
+  if (!device_)
+    return;
+
   D3DPRESENT_PARAMETERS parameters = { 0 };
   parameters.BackBufferWidth = size.width();
   parameters.BackBufferHeight = size.height();
   parameters.BackBufferCount = 1;
   parameters.BackBufferFormat = D3DFMT_A8R8G8B8;
   parameters.hDeviceWindow = window_;
   parameters.Windowed = TRUE;
   parameters.Flags = 0;
   parameters.PresentationInterval = GetPresentationInterval();
   parameters.SwapEffect = D3DSWAPEFFECT_COPY;
@@ skipping 13 matching lines @@
     const base::Closure& completion_task) {
   TRACE_EVENT1("surface", "DoPresentAndAcknowledge", "surface_id", surface_id);
 
   HRESULT hr;
 
   base::AutoLock locked(lock_);
 
   // Ensure the task is always run and while the lock is taken.
   base::ScopedClosureRunner scoped_completion_runner(completion_task);
 
+  if (!device_)
+    return;
+
   if (!window_)
     return;
 
   HANDLE handle = reinterpret_cast<HANDLE>(surface_id);
   if (!handle)
     return;
 
   base::win::ScopedComPtr<IDirect3DTexture9> source_texture;
   {
     TRACE_EVENT0("surface", "CreateTexture");
@@ skipping 45 matching lines @@
 
   ::SetWindowPos(
       window_,
       NULL,
       0, 0,
       size.width(), size.height(),
       SWP_NOACTIVATE | SWP_NOCOPYBITS | SWP_NOMOVE |SWP_NOOWNERZORDER |
           SWP_NOREDRAW | SWP_NOSENDCHANGING | SWP_NOSENDCHANGING |
           SWP_ASYNCWINDOWPOS);
 
+  // Wait for the StretchRect to complete before notifying the GPU process
+  // that it is safe to write to its backing store again.
+  {
+    TRACE_EVENT0("surface", "spin");
+    do {
+      hr = query_->GetData(NULL, 0, D3DGETDATA_FLUSH);
+
+      if (hr == S_FALSE)
+        Sleep(0);
+    } while (hr == S_FALSE);

[Ken Russell (switch to Gerrit), 2011/12/08 01:55:07]

As an FYI a problem in a similarly structured loop was reported in
http://code.google.com/p/angleproject/issues/detail?id=262 .

+  }
+
   scoped_completion_runner.Release();
-  if (!completion_task.is_null()) {
-    g_present_thread_pool.Pointer()->AcknowledgeQuery(FROM_HERE,
-                                                      query_,
-                                                      completion_task);
-  }
+  if (!completion_task.is_null())
+    completion_task.Run();
 
   {
     TRACE_EVENT0("surface", "Present");
     hr = device_->Present(&rect, &rect, NULL, NULL);
     if (FAILED(hr))
       return;
   }
 }