Use occlusion query to test if blit is finished

ui/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/surface/accelerated_surface_win.h"
 
 #include <windows.h>
 #include <algorithm>
 
 #include "base/bind.h"
@@ skipping 19 matching lines @@
 
 namespace {
 
 typedef HRESULT (WINAPI *Direct3DCreate9ExFunc)(UINT sdk_version,
                                                 IDirect3D9Ex **d3d);
 
 const wchar_t kD3D9ModuleName[] = L"d3d9.dll";
 const char kCreate3D9DeviceExName[] = "Direct3DCreate9Ex";
 
 const char kGpuBlitDelay[] = "gpu-blit-delay";
+const char kUseOcclusionQuery[] = "use-occlusion-query";
 
 struct Vertex {
   float x, y, z, w;
   float u, v;
 };
 
 // See accelerated_surface_win.hlsl for source and compilation instructions.
 const BYTE g_vertexMain[] = {
     0,   2, 254, 255, 254, 255,
    22,   0,  67,  84,  65,  66,
@@ skipping 63 matching lines @@
   D3DDECL_END()
 };
 
 UINT GetPresentationInterval() {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableGpuVsync))
     return D3DPRESENT_INTERVAL_IMMEDIATE;
   else
     return D3DPRESENT_INTERVAL_ONE;
 }
 
+bool UsingOcclusionQuery() {
+  return CommandLine::ForCurrentProcess()->HasSwitch(kUseOcclusionQuery);
+}
+
 // Calculate the number necessary to transform |src_subrect| into |dst_size|
 // by repeating downsampling of the image of |src_subrect| by a factor no more
 // than 2.
 int GetResampleCount(const gfx::Rect& src_subrect,
                      const gfx::Size& dst_size,
                      const gfx::Size& back_buffer_size) {
   if (src_subrect.size() == dst_size) {
     // Even when the size of |src_subrect| is equal to |dst_size|, it is
     // necessary to resample pixels at least once unless |src_subrect| exactly
     // covers the back buffer.
@@ skipping 157 matching lines @@
       D3DDEVTYPE_HAL,
       window,
       D3DCREATE_FPU_PRESERVE | D3DCREATE_SOFTWARE_VERTEXPROCESSING |
           D3DCREATE_DISABLE_PSGP_THREADING | D3DCREATE_MULTITHREADED,
       &parameters,
       NULL,
       device_.Receive());
   if (FAILED(hr))
     return;
 
-  hr = device_->CreateQuery(D3DQUERYTYPE_EVENT, query_.Receive());
-  if (FAILED(hr)) {
-    device_ = NULL;
-    return;
+  if (UsingOcclusionQuery()) {
+    hr = device_->CreateQuery(D3DQUERYTYPE_OCCLUSION, query_.Receive());
+    if (FAILED(hr)) {
+      device_ = NULL;
+      return;
+    }
+  } else {
+    hr = device_->CreateQuery(D3DQUERYTYPE_EVENT, query_.Receive());
+    if (FAILED(hr)) {
+      device_ = NULL;
+      return;
+    }
   }
 
   base::win::ScopedComPtr<IDirect3DVertexShader9> vertex_shader;
   hr = device_->CreateVertexShader(reinterpret_cast<const DWORD*>(g_vertexMain),
                                    vertex_shader.Receive());
   if (FAILED(hr)) {
     device_ = NULL;
     query_ = NULL;
     return;
   }
@@ skipping 480 matching lines @@
 
     float halfPixelX = -1.0f / size.width();
     float halfPixelY = 1.0f / size.height();
     Vertex vertices[] = {
       { halfPixelX - 1, halfPixelY + 1, 0.5f, 1, 0, 1 },
       { halfPixelX + 1, halfPixelY + 1, 0.5f, 1, 1, 1 },
       { halfPixelX + 1, halfPixelY - 1, 0.5f, 1, 1, 0 },
       { halfPixelX - 1, halfPixelY - 1, 0.5f, 1, 0, 0 }
     };
 
+    if (UsingOcclusionQuery()) {
+      present_thread_->query()->Issue(D3DISSUE_BEGIN);
+    }
+
     present_thread_->device()->BeginScene();
     present_thread_->device()->DrawPrimitiveUP(D3DPT_TRIANGLEFAN,
                                                arraysize(vertices),
                                                vertices,
                                                sizeof(vertices[0]));
     present_thread_->device()->EndScene();
 
     present_thread_->device()->SetTexture(0, NULL);
     present_thread_->device()->SetRenderTarget(0, default_render_target);
     default_render_target->Release();
@@ skipping 65 matching lines @@
   return presenter_->CopyTo(src_subrect, dst_size, buf);
 }
 
 void AcceleratedSurface::Suspend() {
   presenter_->Suspend();
 }
 
 void AcceleratedSurface::WasHidden() {
   presenter_->WasHidden();
 }