Revert 174920

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 <dwmapi.h>
 #include <windows.h>
 #include <algorithm>
 
@@ skipping 251 matching lines @@
 
 // static
 scoped_refptr<AcceleratedPresenter> AcceleratedPresenter::GetForWindow(
     gfx::PluginWindowHandle window) {
   return g_accelerated_presenter_map.Pointer()->GetPresenter(window);
 }
 
 void AcceleratedPresenter::AsyncPresentAndAcknowledge(
     const gfx::Size& size,
     int64 surface_handle,
-    const CopyCompletionTask& copy_completion_task,
-    const PresentCompletionTask& present_completion_task) {
+    const CompletionTask& completion_task) {
   if (!surface_handle) {
     TRACE_EVENT1("gpu", "EarlyOut_ZeroSurfaceHandle",
                  "surface_handle", surface_handle);
-    copy_completion_task.Run(true);
-    present_completion_task.Run(base::TimeTicks(), base::TimeDelta());
+    completion_task.Run(true, base::TimeTicks(), base::TimeDelta());
     return;
   }
 
   present_thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&AcceleratedPresenter::DoPresentAndAcknowledge,
                  this,
                  size,
                  surface_handle,
-                 copy_completion_task,
-                 present_completion_task));
+                 completion_task));
 }
 
 void AcceleratedPresenter::Present(HDC dc) {
   TRACE_EVENT0("gpu", "Present");
 
   base::AutoLock locked(lock_);
 
   // If invalidated, do nothing. The window is gone.
   if (!window_)
     return;
@@ skipping 165 matching lines @@
   if (cmd_line->HasSwitch(switches::kGpuSwapDelay)) {
     base::StringToInt(cmd_line->GetSwitchValueNative(
         switches::kGpuSwapDelay).c_str(), &delay);
   }
   return base::TimeDelta::FromMilliseconds(delay);
 }
 
 void AcceleratedPresenter::DoPresentAndAcknowledge(
     const gfx::Size& size,
     int64 surface_handle,
-    const CopyCompletionTask& copy_completion_task,
-    const PresentCompletionTask& present_completion_task) {
+    const CompletionTask& completion_task) {
   TRACE_EVENT2(
       "gpu", "DoPresentAndAcknowledge",
       "width", size.width(),
       "height", size.height());
 
   HRESULT hr;
 
   base::AutoLock locked(lock_);
 
   // Initialize the device lazily since calling Direct3D can crash bots.
   present_thread_->InitDevice();
 
   if (!present_thread_->device()) {
-    if (!copy_completion_task.is_null())
-      copy_completion_task.Run(false);
-    if (!present_completion_task.is_null())
-      present_completion_task.Run(base::TimeTicks(), base::TimeDelta());
+    if (!completion_task.is_null())
+      completion_task.Run(false, base::TimeTicks(), base::TimeDelta());
     TRACE_EVENT0("gpu", "EarlyOut_NoDevice");
     return;
   }
 
   // Ensure the task is always run and while the lock is taken.
-  base::ScopedClosureRunner scoped_copy_completion_runner(
-      base::Bind(copy_completion_task, true));
-  base::ScopedClosureRunner scoped_present_completion_runner(
-      base::Bind(present_completion_task,
-      base::TimeTicks(),
-      base::TimeDelta()));
+  base::ScopedClosureRunner scoped_completion_runner(
+      base::Bind(completion_task, true, base::TimeTicks(), base::TimeDelta()));
 
   // If invalidated, do nothing, the window is gone.
   if (!window_) {
     TRACE_EVENT0("gpu", "EarlyOut_NoWindow");
     return;
   }
 
 #if !defined(USE_AURA)
   // If the window is a different size than the swap chain that is being
   // presented then drop the frame.
@@ skipping 82 matching lines @@
     bool result = present_thread_->surface_transformer()->CopyInverted(
         source_texture_, dest_surface, size);
     if (!result)
       return;
   }
 
   hr = present_thread_->query()->Issue(D3DISSUE_END);
   if (FAILED(hr))
     return;
 
-  // Wait for the StretchRect to complete before notifying the GPU process
-  // that it is safe to write to its backing store again.
-  {
-    TRACE_EVENT0("gpu", "spin");
-    do {
-      hr = present_thread_->query()->GetData(NULL, 0, D3DGETDATA_FLUSH);
-
-      if (hr == S_FALSE)
-        Sleep(1);
-    } while (hr == S_FALSE);
-  }
-
-  // Acknowledge that the copy is complete and it is safe to modify the shared
-  // texture.
-  scoped_copy_completion_runner.Release();
-  copy_completion_task.Run(true);
-
   present_size_ = size;
 
   static const base::TimeDelta swap_delay = GetSwapDelay();
   if (swap_delay.ToInternalValue())
     base::PlatformThread::Sleep(swap_delay);
 
   // If it is expected that Direct3D cannot be used reliably because the window
   // is resizing, fall back to presenting with GDI.
   if (CheckDirect3DWillWork()) {
     TRACE_EVENT0("gpu", "PresentD3D");
@@ skipping 45 matching lines @@
   base::TimeTicks last_vsync_time;
   base::TimeDelta refresh_period;
   if (display_mode.Height) {
       last_vsync_time = current_time -
         base::TimeDelta::FromMilliseconds((clamped_scanline * 1000) /
             (display_mode.RefreshRate * display_mode.Height));
       refresh_period = base::TimeDelta::FromMicroseconds(
           1000000 / display_mode.RefreshRate);
   }
 
-  scoped_present_completion_runner.Release();
-  present_completion_task.Run(last_vsync_time, refresh_period);
+  // Wait for the StretchRect to complete before notifying the GPU process
+  // that it is safe to write to its backing store again.
+  {
+    TRACE_EVENT0("gpu", "spin");
+    do {
+      hr = present_thread_->query()->GetData(NULL, 0, D3DGETDATA_FLUSH);
+
+      if (hr == S_FALSE)
+        Sleep(1);
+    } while (hr == S_FALSE);
+  }
+
+  scoped_completion_runner.Release();
+  completion_task.Run(true, last_vsync_time, refresh_period);
 }
 
 void AcceleratedPresenter::DoSuspend() {
   base::AutoLock locked(lock_);
   swap_chain_ = NULL;
 }
 
 void AcceleratedPresenter::DoReleaseSurface() {
   base::AutoLock locked(lock_);
   present_thread_->InitDevice();
@@ skipping 121 matching lines @@
   presenter_->AsyncCopyTo(src_subrect, dst_size, buf, callback);
 }
 
 void AcceleratedSurface::Suspend() {
   presenter_->Suspend();
 }
 
 void AcceleratedSurface::WasHidden() {
   presenter_->WasHidden();
 }