Ensure that PresentThreadPool is initialized on the UI thread.

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 "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 32 matching lines @@
 // A PresentThread is a thread that is dedicated to presenting surfaces to a
 // window. It owns a Direct3D device and a Direct3D query for this purpose.
 class PresentThread : public base::Thread {
  public:
   PresentThread(const char* name);
   ~PresentThread();
 
   IDirect3DDevice9* device() { return device_.get(); }
   IDirect3DQuery9* query() { return query_.get(); }
 
+  void InitDevice();
   void ResetDevice();
 
  protected:
-  virtual void Init();
   virtual void CleanUp();
 
  private:
   base::ScopedNativeLibrary d3d_module_;
   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_;
@@ skipping 20 matching lines @@
 base::LazyInstance<PresentThreadPool>
     g_present_thread_pool = LAZY_INSTANCE_INITIALIZER;
 
 PresentThread::PresentThread(const char* name) : base::Thread(name) {
 }
 
 PresentThread::~PresentThread() {
   Stop();
 }
 
+void PresentThread::InitDevice() {
+  if (device_)
+    return;
+
+  TRACE_EVENT0("surface", "PresentThread::Init");
+  d3d_module_.Reset(base::LoadNativeLibrary(FilePath(kD3D9ModuleName), NULL));
+  ResetDevice();
+}
+
 void PresentThread::ResetDevice() {
   TRACE_EVENT0("surface", "PresentThread::ResetDevice");
 
   // This will crash some Intel drivers but we can't render anything without
   // reseting the device, which would be disappointing.
   query_ = NULL;
   device_ = NULL;
 
   Direct3DCreate9ExFunc create_func = reinterpret_cast<Direct3DCreate9ExFunc>(
       d3d_module_.GetFunctionPointer(kCreate3D9DeviceExName));
@@ skipping 30 matching lines @@
       NULL,
       device_.Receive());
   if (FAILED(hr))
     return;
 
   hr = device_->CreateQuery(D3DQUERYTYPE_EVENT, query_.Receive());
   if (FAILED(hr))
     device_ = NULL;
 }
 
-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();
   query_.Detach();
 }
 
 PresentThreadPool::PresentThreadPool() : next_thread_(0) {
+  // Do this in the constructor so present_threads_ is initialized before any
+  // other thread sees it. See LazyInstance documentation.
+  for (int i = 0; i < kNumPresentThreads; ++i) {
+    present_threads_[i].reset(new PresentThread(
+        base::StringPrintf("PresentThread #%d", i).c_str()));
+    present_threads_[i]->Start();
+  }
 }
 
 PresentThread* PresentThreadPool::NextThread() {
   next_thread_ = (next_thread_ + 1) % kNumPresentThreads;
-  if (!present_threads_[next_thread_].get()) {
-    present_threads_[next_thread_].reset(new PresentThread(
-        base::StringPrintf("PresentThread #%d", next_thread_).c_str()));
-    present_threads_[next_thread_]->Start();
-  }
   return present_threads_[next_thread_].get();
 }
 
 AcceleratedPresenter::AcceleratedPresenter()
     : present_thread_(g_present_thread_pool.Pointer()->NextThread()) {
 }
 
 void AcceleratedPresenter::AsyncPresentAndAcknowledge(
     gfx::NativeWindow window,
     const gfx::Size& size,
     int64 surface_id,
     const base::Callback<void(bool)>& completion_task) {
   present_thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&AcceleratedPresenter::DoPresentAndAcknowledge,
                  this,
                  window,
                  size,
                  surface_id,
                  completion_task));
 }
 
 bool AcceleratedPresenter::Present(gfx::NativeWindow window) {
   TRACE_EVENT0("surface", "Present");
 
   HRESULT hr;
 
   base::AutoLock locked(lock_);
 
-  // Signal the caller to recomposite if the presenter has been suspended.
+  // Signal the caller to recomposite if the presenter has been suspended or no
+  // surface has ever been presented.
   if (!swap_chain_)
     return false;
 
   RECT rect = {
     0, 0,
     size_.width(), size_.height()
   };
 
   {
     TRACE_EVENT0("surface", "PresentEx");
@@ skipping 49 matching lines @@
     gfx::NativeWindow window,
     const gfx::Size& size,
     int64 surface_id,
     const base::Callback<void(bool)>& completion_task) {
   TRACE_EVENT1("surface", "DoPresentAndAcknowledge", "surface_id", surface_id);
 
   HRESULT hr;
 
   base::AutoLock locked(lock_);
 
+  // Initialize the device lazily since calling Direct3D can crash bots.
+  present_thread_->InitDevice();
+
+  // A surface with ID zero is presented even when shared surfaces are not in
+  // use for synchronization purposes. In that case, just acknowledge.
+  if (!surface_id) {
+    if (!completion_task.is_null())
+      completion_task.Run(true);
+    return;
+  }
+
   if (!present_thread_->device()) {
     if (!completion_task.is_null())
       completion_task.Run(false);
     return;
   }
 
   // Ensure the task is always run and while the lock is taken.
   base::ScopedClosureRunner scoped_completion_runner(base::Bind(completion_task,
                                                                 true));
 
@@ skipping 22 matching lines @@
     parameters.SwapEffect = D3DSWAPEFFECT_COPY;
 
     swap_chain_ = NULL;
     HRESULT hr = present_thread_->device()->CreateAdditionalSwapChain(
         &parameters,
         swap_chain_.Receive());
     if (FAILED(hr))
       return;
   }
 
-  HANDLE handle = reinterpret_cast<HANDLE>(surface_id);
-  if (!handle)
-    return;
-
   base::win::ScopedComPtr<IDirect3DTexture9> source_texture;
   {
     TRACE_EVENT0("surface", "CreateTexture");
+    HANDLE handle = reinterpret_cast<HANDLE>(surface_id);
     hr = present_thread_->device()->CreateTexture(size.width(),
                                                   size.height(),
                                                   1,
                                                   D3DUSAGE_RENDERTARGET,
                                                   D3DFMT_A8R8G8B8,
                                                   D3DPOOL_DEFAULT,
                                                   source_texture.Receive(),
                                                   &handle);
     if (FAILED(hr))
       return;
@@ skipping 66 matching lines @@
     if (FAILED(hr))
       present_thread_->ResetDevice();
   }
 }
 
 void AcceleratedPresenter::DoSuspend() {
   base::AutoLock locked(lock_);
   swap_chain_ = NULL;
 }
 
-AcceleratedSurface::AcceleratedSurface(){
+AcceleratedSurface::AcceleratedSurface()
+    : presenter_(new AcceleratedPresenter) {
 }
 
 AcceleratedSurface::~AcceleratedSurface() {
-  if (presenter_) {
-    // Ensure that the swap chain is destroyed on the PresentThread in case
-    // there are still pending presents.
-    presenter_->Suspend();
-    presenter_->WaitForPendingTasks();
-  }
+  // Ensure that the swap chain is destroyed on the PresentThread in case
+  // there are still pending presents.
+  presenter_->Suspend();
+  presenter_->WaitForPendingTasks();
 }
 
 void AcceleratedSurface::AsyncPresentAndAcknowledge(
     HWND window,
     const gfx::Size& size,
     int64 surface_id,
     const base::Callback<void(bool)>& completion_task) {
   if (!surface_id)
     return;
 
-  if (!presenter_)
-    presenter_ = new AcceleratedPresenter;
-
   presenter_->AsyncPresentAndAcknowledge(window,
                                          size,
                                          surface_id,
                                          completion_task);
 }
 
 bool AcceleratedSurface::Present(HWND window) {
-  if (presenter_)
-    return presenter_->Present(window);
-  else
-    return false;
+  return presenter_->Present(window);
 }
 
 void AcceleratedSurface::Suspend() {
-  if (presenter_)
-    presenter_->Suspend();
+  presenter_->Suspend();
 }