Revert of Create GPU child window on new thread.

gpu/ipc/service/child_window_surface_win.cc

 // Copyright 2015 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 "gpu/ipc/service/child_window_surface_win.h"
 
 #include <memory>
 
 #include "base/compiler_specific.h"
-#include "base/memory/ptr_util.h"
-#include "base/threading/thread.h"
 #include "base/win/scoped_hdc.h"
 #include "base/win/wrapped_window_proc.h"
 #include "gpu/ipc/common/gpu_messages.h"
 #include "gpu/ipc/service/gpu_channel_manager.h"
 #include "gpu/ipc/service/gpu_channel_manager_delegate.h"
 #include "ui/base/win/hidden_window.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/win/hwnd_util.h"
 #include "ui/gl/egl_util.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/scoped_make_current.h"
 
 namespace gpu {
 
-// This owns the thread and contains data that's shared between the threads.
-struct SharedData {
-  SharedData() : thread("Window owner thread") {}
-
-  base::Lock rect_lock;
-  gfx::Rect rect_to_clear;
-
-  base::Thread thread;
-};
-
 namespace {
 
 ATOM g_window_class;
 
-// This runs on the window owner thread.
 LRESULT CALLBACK IntermediateWindowProc(HWND window,
                                         UINT message,
                                         WPARAM w_param,
                                         LPARAM l_param) {
   switch (message) {
     case WM_ERASEBKGND:
       // Prevent windows from erasing the background.
       return 1;
     case WM_PAINT:
       PAINTSTRUCT paint;
       if (BeginPaint(window, &paint)) {
-        SharedData* shared_data =
-            reinterpret_cast<SharedData*>(gfx::GetWindowUserData(window));
-        DCHECK(shared_data);
-        {
-          base::AutoLock lock(shared_data->rect_lock);
-          shared_data->rect_to_clear.Union(gfx::Rect(paint.rcPaint));
-        }
+        ChildWindowSurfaceWin* window_surface =
+            reinterpret_cast<ChildWindowSurfaceWin*>(
+                gfx::GetWindowUserData(window));
+        DCHECK(window_surface);
 
+        // Wait to clear the contents until a GL draw occurs, as otherwise an
+        // unsightly black flash may happen if the GL contents are still
+        // transparent.
+        window_surface->InvalidateWindowRect(gfx::Rect(paint.rcPaint));
         EndPaint(window, &paint);
       }
       return 0;
     default:
       return DefWindowProc(window, message, w_param, l_param);
   }
 }
 
-// This runs on the window owner thread.
 void InitializeWindowClass() {
   if (g_window_class)
     return;
 
   WNDCLASSEX intermediate_class;
   base::win::InitializeWindowClass(
       L"Intermediate D3D Window",
       &base::win::WrappedWindowProc<IntermediateWindowProc>, CS_OWNDC, 0, 0,
       nullptr, reinterpret_cast<HBRUSH>(GetStockObject(BLACK_BRUSH)), nullptr,
       nullptr, nullptr, &intermediate_class);
   g_window_class = RegisterClassEx(&intermediate_class);
   if (!g_window_class) {
     LOG(ERROR) << "RegisterClass failed.";
     return;
   }
 }
-
-// This runs on the window owner thread.
-void CreateChildWindow(HWND parent,
-                       base::WaitableEvent* event,
-                       SharedData* shared_data,
-                       HWND* result) {
-  InitializeWindowClass();
-  DCHECK(g_window_class);
-
-  RECT windowRect;
-  GetClientRect(parent, &windowRect);
-
-  HWND window = CreateWindowEx(
-      WS_EX_NOPARENTNOTIFY, reinterpret_cast<wchar_t*>(g_window_class), L"",
-      WS_CHILDWINDOW | WS_DISABLED | WS_VISIBLE, 0, 0,
-      windowRect.right - windowRect.left, windowRect.bottom - windowRect.top,
-      ui::GetHiddenWindow(), NULL, NULL, NULL);
-  *result = window;
-  gfx::SetWindowUserData(window, shared_data);
-  event->Signal();
 }
 
-// This runs on the main thread after the window was destroyed on window owner
-// thread.
-void DestroySharedData(std::unique_ptr<SharedData> shared_data) {
-  shared_data->thread.Stop();
-}
-
-// This runs on the window owner thread.
-void DestroyWindowOnThread(HWND window) {
-  DestroyWindow(window);
-}
-
-}  // namespace
-
 ChildWindowSurfaceWin::ChildWindowSurfaceWin(GpuChannelManager* manager,
                                              HWND parent_window)
     : gl::NativeViewGLSurfaceEGL(0),
       parent_window_(parent_window),
       manager_(manager),
       alpha_(true),
       first_swap_(true) {
   // Don't use EGL_ANGLE_window_fixed_size so that we can avoid recreating the
   // window surface, which can cause flicker on DirectComposition.
   enable_fixed_size_angle_ = false;
@@ skipping 25 matching lines @@
       return NULL;
     }
   }
 
   return config_;
 }
 
 bool ChildWindowSurfaceWin::InitializeNativeWindow() {
   if (window_)
     return true;
+  InitializeWindowClass();
+  DCHECK(g_window_class);
 
-  shared_data_ = base::MakeUnique<SharedData>();
+  RECT windowRect;
+  GetClientRect(parent_window_, &windowRect);
 
-  base::Thread::Options options(base::MessageLoop::TYPE_UI, 0);
-  shared_data_->thread.StartWithOptions(options);
-
-  base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
-                            base::WaitableEvent::InitialState::NOT_SIGNALED);
-  shared_data_->thread.task_runner()->PostTask(
-      FROM_HERE, base::Bind(&CreateChildWindow, parent_window_, &event,
-                            shared_data_.get(), &window_));
-  event.Wait();
-
+  window_ = CreateWindowEx(
+      WS_EX_NOPARENTNOTIFY, reinterpret_cast<wchar_t*>(g_window_class), L"",
+      WS_CHILDWINDOW | WS_DISABLED | WS_VISIBLE, 0, 0,
+      windowRect.right - windowRect.left, windowRect.bottom - windowRect.top,
+      ui::GetHiddenWindow(), NULL, NULL, NULL);
+  gfx::SetWindowUserData(window_, this);
   manager_->delegate()->SendAcceleratedSurfaceCreatedChildWindow(parent_window_,
                                                                  window_);
   return true;
 }
 
 bool ChildWindowSurfaceWin::Resize(const gfx::Size& size,
                                    float scale_factor,
                                    bool has_alpha) {
   if (!SupportsPostSubBuffer()) {
     if (!MoveWindow(window_, 0, 0, size.width(), size.height(), FALSE)) {
@@ skipping 56 matching lines @@
 gfx::SwapResult ChildWindowSurfaceWin::PostSubBuffer(int x,
                                                      int y,
                                                      int width,
                                                      int height) {
   gfx::SwapResult result =
       NativeViewGLSurfaceEGL::PostSubBuffer(x, y, width, height);
   ClearInvalidContents();
   return result;
 }
 
+void ChildWindowSurfaceWin::InvalidateWindowRect(const gfx::Rect& rect) {
+  rect_to_clear_.Union(rect);
+}
+
 void ChildWindowSurfaceWin::ClearInvalidContents() {
-  base::AutoLock lock(shared_data_->rect_lock);
-  if (!shared_data_->rect_to_clear.IsEmpty()) {
+  if (!rect_to_clear_.IsEmpty()) {
     base::win::ScopedGetDC dc(window_);
 
-    RECT rect = shared_data_->rect_to_clear.ToRECT();
+    RECT rect = rect_to_clear_.ToRECT();
 
     // DirectComposition composites with the contents under the SwapChain,
     // so ensure that's cleared. GDI treats black as transparent.
     FillRect(dc, &rect, reinterpret_cast<HBRUSH>(GetStockObject(BLACK_BRUSH)));
-    shared_data_->rect_to_clear = gfx::Rect();
+    rect_to_clear_ = gfx::Rect();
   }
 }
 
 ChildWindowSurfaceWin::~ChildWindowSurfaceWin() {
-  if (shared_data_) {
-    scoped_refptr<base::TaskRunner> task_runner =
-        shared_data_->thread.task_runner();
-    task_runner->PostTaskAndReply(
-        FROM_HERE, base::Bind(&DestroyWindowOnThread, window_),
-        base::Bind(&DestroySharedData, base::Passed(std::move(shared_data_))));
-  }
+  gfx::SetWindowUserData(window_, nullptr);
+  DestroyWindow(window_);
 }
 
 }  // namespace gpu