Do DXVA pre-sandbox initialization off the main thread.

content/common/gpu/media/dxva_video_decode_accelerator.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 "content/common/gpu/media/dxva_video_decode_accelerator.h"
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
 #endif   // !defined(OS_WIN)
 
 #include <ks.h>
 #include <codecapi.h>
 #include <mfapi.h>
 #include <mferror.h>
 #include <wmcodecdsp.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_handle.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
+#include "base/threading/worker_pool.h"
 #include "media/video/video_decode_accelerator.h"
 #include "third_party/angle/include/EGL/egl.h"
 #include "third_party/angle/include/EGL/eglext.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_switches.h"
 
 namespace content {
 
 // We only request 5 picture buffers from the client which are used to hold the
@@ skipping 323 matching lines @@
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::PendingSampleInfo(
     int32 buffer_id, IMFSample* sample)
     : input_buffer_id(buffer_id) {
   output_sample.Attach(sample);
 }
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::~PendingSampleInfo() {}
 
 // static
-void DXVAVideoDecodeAccelerator::PreSandboxInitialization() {
+// Initializes DXVA on a separate thread.
+void DXVAVideoDecodeAccelerator::PreSandboxInitialization(
+    const base::Closure& completion_task) {
   // Should be called only once during program startup.
   DCHECK(!pre_sandbox_init_done_);
 
+  base::ScopedClosureRunner scoped_completion_runner(completion_task);
+
   static wchar_t* decoding_dlls[] = {
     L"d3d9.dll",
     L"dxva2.dll",
     L"mf.dll",
     L"mfplat.dll",
     L"msmpeg2vdec.dll",
   };
 
   for (int i = 0; i < arraysize(decoding_dlls); ++i) {
     if (!::LoadLibrary(decoding_dlls[i])) {
       DLOG(ERROR) << "Failed to load decoder dll: " << decoding_dlls[i]
                   << ", Error: " << ::GetLastError();
       return;
     }
   }
 
-  RETURN_ON_FAILURE(CreateD3DDevManager(),
-                    "Failed to initialize D3D device and manager",);
-  pre_sandbox_init_done_ = true;
+  HRESULT hr = Direct3DCreate9Ex(D3D_SDK_VERSION, &d3d9_);
+  RETURN_ON_HR_FAILURE(hr,
+                       "Failed to initialize D3D9.",);
+
+  // Initialize H/W video decoding stuff which fails in the sandbox. This is
+  // done on a worker thread because it takes 10s of ms.
+  scoped_completion_runner.Release();
+  base::WorkerPool::PostTask(
+      FROM_HERE,
+      base::Bind(&DXVAVideoDecodeAccelerator::CreateD3DDevManager,
+                 completion_task),
+      true);
 }
 
 // static
-bool DXVAVideoDecodeAccelerator::CreateD3DDevManager() {
-  HRESULT hr = Direct3DCreate9Ex(D3D_SDK_VERSION, &d3d9_);
-  RETURN_ON_HR_FAILURE(hr, "Direct3DCreate9Ex failed", false);
+void DXVAVideoDecodeAccelerator::CreateD3DDevManager(
+    const base::Closure& completion_task) {
+  base::ScopedClosureRunner scoped_completion_runner(completion_task);
 
   D3DPRESENT_PARAMETERS present_params = {0};
   present_params.BackBufferWidth = 1;
   present_params.BackBufferHeight = 1;
   present_params.BackBufferFormat = D3DFMT_UNKNOWN;
   present_params.BackBufferCount = 1;
   present_params.SwapEffect = D3DSWAPEFFECT_DISCARD;
   present_params.hDeviceWindow = ::GetShellWindow();
   present_params.Windowed = TRUE;
   present_params.Flags = D3DPRESENTFLAG_VIDEO;
   present_params.FullScreen_RefreshRateInHz = 0;
   present_params.PresentationInterval = 0;
 
-  hr = d3d9_->CreateDeviceEx(D3DADAPTER_DEFAULT,
-                             D3DDEVTYPE_HAL,
-                             ::GetShellWindow(),
-                             D3DCREATE_FPU_PRESERVE |
-                             D3DCREATE_SOFTWARE_VERTEXPROCESSING |
-                             D3DCREATE_DISABLE_PSGP_THREADING |
-                             D3DCREATE_MULTITHREADED,
-                             &present_params,
-                             NULL,
-                             &device_);
-  RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device", false);
+  HRESULT hr = d3d9_->CreateDeviceEx(D3DADAPTER_DEFAULT,
+                                     D3DDEVTYPE_HAL,
+                                     ::GetShellWindow(),
+                                     D3DCREATE_FPU_PRESERVE |
+                                     D3DCREATE_SOFTWARE_VERTEXPROCESSING |
+                                     D3DCREATE_DISABLE_PSGP_THREADING |
+                                     D3DCREATE_MULTITHREADED,
+                                     &present_params,
+                                     NULL,
+                                     &device_);
+  RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device",);
 
   hr = DXVA2CreateDirect3DDeviceManager9(&dev_manager_reset_token_,
                                          &device_manager_);
-  RETURN_ON_HR_FAILURE(hr, "DXVA2CreateDirect3DDeviceManager9 failed", false);
+  RETURN_ON_HR_FAILURE(hr, "DXVA2CreateDirect3DDeviceManager9 failed",);
 
   hr = device_manager_->ResetDevice(device_, dev_manager_reset_token_);
-  RETURN_ON_HR_FAILURE(hr, "Failed to reset device", false);
+  RETURN_ON_HR_FAILURE(hr, "Failed to reset device",);
 
   hr = device_->CreateQuery(D3DQUERYTYPE_EVENT, &query_);
-  RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device query", false);
+  RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device query",);
+
   // Ensure query_ API works (to avoid an infinite loop later in
   // CopyOutputSampleDataToPictureBuffer).
   hr = query_->Issue(D3DISSUE_END);
-  RETURN_ON_HR_FAILURE(hr, "Failed to issue END test query", false);
-  return true;
+  RETURN_ON_HR_FAILURE(hr, "Failed to issue END test query",);
+
+  pre_sandbox_init_done_ = true;
 }
 
 DXVAVideoDecodeAccelerator::DXVAVideoDecodeAccelerator(
     media::VideoDecodeAccelerator::Client* client,
     const base::Callback<bool(void)>& make_context_current)
     : client_(client),
       egl_config_(NULL),
       state_(kUninitialized),
       pictures_requested_(false),
       inputs_before_decode_(0),
@@ skipping 626 matching lines @@
       return;
   }
 
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &DXVAVideoDecodeAccelerator::NotifyFlushDone, base::AsWeakPtr(this)));
 
   state_ = kNormal;
 }
 
 }  // namespace content