WIP - Gutterless resize on Windows

ui/base/window_resize_helper.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 "ui/accelerated_widget_mac/window_resize_helper_mac.h"
+#include "ui/base/window_resize_helper.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
 
@@ skipping 81 matching lines @@
   base::WaitableEvent event_;
 
   // Callback to call TimedWait on |event_| from an appropriate class.
   EventTimedWaitCallback event_timed_wait_callback_;
 
   scoped_refptr<base::SingleThreadTaskRunner> target_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(PumpableTaskRunner);
 };
 
-base::LazyInstance<WindowResizeHelperMac>::Leaky g_window_resize_helper =
+base::LazyInstance<WindowResizeHelper>::Leaky g_window_resize_helper =
     LAZY_INSTANCE_INITIALIZER;
 
 ////////////////////////////////////////////////////////////////////////////////
 // WrappedTask
 
 WrappedTask::WrappedTask(const base::Closure& closure, base::TimeDelta delay)
     : closure_(closure),
       can_run_time_(base::TimeTicks::Now() + delay),
       has_run_(false),
       sequence_number_(0) {}
@@ skipping 153 matching lines @@
   return false;
 }
 
 bool PumpableTaskRunner::RunsTasksOnCurrentThread() const {
   return target_task_runner_->RunsTasksOnCurrentThread();
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
-// WindowResizeHelperMac
+// WindowResizeHelper
 
-scoped_refptr<base::SingleThreadTaskRunner> WindowResizeHelperMac::task_runner()
+scoped_refptr<base::SingleThreadTaskRunner> WindowResizeHelper::task_runner()
     const {
   return task_runner_;
 }
 
 // static
-WindowResizeHelperMac* WindowResizeHelperMac::Get() {
+WindowResizeHelper* WindowResizeHelper::Get() {
   return g_window_resize_helper.Pointer();
 }
 
-void WindowResizeHelperMac::Init(
+void WindowResizeHelper::Init(
     const scoped_refptr<base::SingleThreadTaskRunner>& target_task_runner) {
   DCHECK(!task_runner_);
   task_runner_ = new PumpableTaskRunner(
-      base::Bind(&WindowResizeHelperMac::EventTimedWait), target_task_runner);
+      base::Bind(&WindowResizeHelper::EventTimedWait), target_task_runner);
 }
 
-bool WindowResizeHelperMac::WaitForSingleTaskToRun(
+bool WindowResizeHelper::WaitForSingleTaskToRun(
     const base::TimeDelta& max_delay) {
   PumpableTaskRunner* pumpable_task_runner =
       static_cast<PumpableTaskRunner*>(task_runner_.get());
   if (!pumpable_task_runner)
     return false;
   return pumpable_task_runner->WaitForSingleWrappedTaskToRun(max_delay);
 }
 
-WindowResizeHelperMac::WindowResizeHelperMac() {}
-WindowResizeHelperMac::~WindowResizeHelperMac() {}
+WindowResizeHelper::WindowResizeHelper() {}
+WindowResizeHelper::~WindowResizeHelper() {}
 
-void WindowResizeHelperMac::EventTimedWait(base::WaitableEvent* event,
-                                           base::TimeDelta delay) {
+void WindowResizeHelper::EventTimedWait(base::WaitableEvent* event,
+                                        base::TimeDelta delay) {
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   event->TimedWait(delay);
 }
 
 }  // namespace ui