Introduce AndroidFocusRules and NativeWidgetAndroid

ui/views/widget/android/native_widget_android.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// 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/views/widget/native_widget_aura.h"
+#include "ui/views/widget/android/native_widget_android.h"
 
 #include "base/bind.h"
+#include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/cursor_client.h"
+#include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer.h"
 #include "ui/events/event.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/screen.h"
 #include "ui/native_theme/native_theme_aura.h"
 #include "ui/views/drag_utils.h"
 #include "ui/views/views_delegate.h"
+#include "ui/views/widget/android/android_focus_rules.h"
 #include "ui/views/widget/drop_helper.h"
+#include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/native_widget_delegate.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/tooltip_manager_aura.h"
 #include "ui/views/widget/widget_aura_utils.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/views/widget/window_reorderer.h"
+#include "ui/wm/core/default_activation_client.h"
+#include "ui/wm/core/default_screen_position_client.h"
+#include "ui/wm/core/focus_controller.h"
 #include "ui/wm/core/shadow_types.h"
 #include "ui/wm/core/window_animations.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_client.h"
+#include "ui/wm/public/dispatcher_client.h"
 #include "ui/wm/public/drag_drop_client.h"
 #include "ui/wm/public/window_move_client.h"
 #include "ui/wm/public/window_types.h"
 
-#if defined(OS_WIN)
-#include "base/win/scoped_gdi_object.h"
-#include "base/win/win_util.h"
-#include "ui/base/l10n/l10n_util_win.h"
-#include "ui/views/widget/desktop_aura/desktop_window_tree_host_win.h"
-#endif
-
-#if defined(USE_X11) && !defined(OS_CHROMEOS)
-#include "ui/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
-#endif
-
-#if !defined(OS_CHROMEOS)
-#include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
-#include "ui/views/widget/desktop_aura/desktop_window_tree_host.h"
-#endif
-
-namespace views {
+// TODO(bshe): Most of the code is copied from NativeWidgetAura. There will be
+// more differences overtime. For upstreaming purpose, keep the change minimal.
 
 namespace {
 
 void SetRestoreBounds(aura::Window* window, const gfx::Rect& bounds) {
   window->SetProperty(aura::client::kRestoreBoundsKey, new gfx::Rect(bounds));
 }
 
+class NativeWidgetAndroidWindowTreeClient
+    : public aura::client::WindowTreeClient {
+ public:
+  explicit NativeWidgetAndroidWindowTreeClient(aura::Window* root_window)
+      : root_window_(root_window) {
+    aura::client::SetWindowTreeClient(root_window_, this);
+  }
+  ~NativeWidgetAndroidWindowTreeClient() override {
+    aura::client::SetWindowTreeClient(root_window_, NULL);
+  }
+
+  // Overridden from client::WindowTreeClient:
+  aura::Window* GetDefaultParent(aura::Window* context,
+                                 aura::Window* window,
+                                 const gfx::Rect& bounds) override {
+    return root_window_;
+  }
+
+ private:
+  aura::Window* root_window_;
+
+  DISALLOW_COPY_AND_ASSIGN(NativeWidgetAndroidWindowTreeClient);
+};
+
+class AndroidDispatcherClient : public aura::client::DispatcherClient {

[mfomitchev, 2015/11/06 16:45:50]

We are trying to get rid of nested msg loops, so hopefully we won't need this. I
guess It might be useful in the interim to get stuff to compile/run.. so perhaps
add a TODO and reference the nested msg loop bug.

[bshe, 2015/11/11 00:38:30]

Done.

+ public:
+  AndroidDispatcherClient() : dispatcher_(nullptr) {}
+  ~AndroidDispatcherClient() override {}
+
+  base::MessagePumpDispatcher* dispatcher() { return dispatcher_; }
+
+  // aura::client::DispatcherClient:
+  void PrepareNestedLoopClosures(base::MessagePumpDispatcher* dispatcher,
+                                 base::Closure* run_closure,
+                                 base::Closure* quit_closure) override {
+    scoped_ptr<base::RunLoop> run_loop(new base::RunLoop());
+    *quit_closure = run_loop->QuitClosure();
+    *run_closure =
+        base::Bind(&AndroidDispatcherClient::RunNestedDispatcher,
+                   base::Unretained(this), base::Passed(&run_loop), dispatcher);
+  }
+
+ private:
+  void RunNestedDispatcher(scoped_ptr<base::RunLoop> run_loop,
+                           base::MessagePumpDispatcher* dispatcher) {
+    base::AutoReset<base::MessagePumpDispatcher*> reset_dispatcher(&dispatcher_,
+                                                                   dispatcher);
+    base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
+    base::MessageLoop::ScopedNestableTaskAllower allow(loop);
+    run_loop->Run();
+  }
+
+  base::MessagePumpDispatcher* dispatcher_;
+
+  DISALLOW_COPY_AND_ASSIGN(AndroidDispatcherClient);
+};
+
 }  // namespace
 
+namespace views {
+
 ////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetAura, public:
+// NativeWidgetAndroid, public
 
-NativeWidgetAura::NativeWidgetAura(internal::NativeWidgetDelegate* delegate)
+NativeWidgetAndroid::NativeWidgetAndroid(
+    internal::NativeWidgetDelegate* delegate)
     : delegate_(delegate),
       window_(new aura::Window(this)),
       ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET),
       destroying_(false),
       cursor_(gfx::kNullCursor),
       saved_window_state_(ui::SHOW_STATE_DEFAULT),
       close_widget_factory_(this) {
   aura::client::SetFocusChangeObserver(window_, this);
   aura::client::SetActivationChangeObserver(window_, this);
 }
 
-// static
-void NativeWidgetAura::RegisterNativeWidgetForWindow(
-      internal::NativeWidgetPrivate* native_widget,
-      aura::Window* window) {
-  window->set_user_data(native_widget);
-}
+////////////////////////////////////////////////////////////////////////////////
+// NativeWidgetAndroid, NativeWidgetAndroid implementation:
 
-////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetAura, internal::NativeWidgetPrivate implementation:
+void NativeWidgetAndroid::InitNativeWidget(const Widget::InitParams& params) {
+  // TODO(bshe): Get rid of the hard coded size. Tracked in crbug.com/551923.
+  host_.reset(aura::WindowTreeHost::Create(gfx::Rect(0, 0, 800, 600)));
+  host_->InitHost();
+  host_->Show();
 
-void NativeWidgetAura::InitNativeWidget(const Widget::InitParams& params) {
+  window_tree_client_.reset(
+      new NativeWidgetAndroidWindowTreeClient(host_->window()));
+
+  focus_client_.reset(new wm::FocusController(new AndroidFocusRules));
+  aura::client::SetFocusClient(host_->window(), focus_client_.get());
+  host_->window()->AddPreTargetHandler(focus_client_.get());
+
+  new wm::DefaultActivationClient(host_->window());
+
+  capture_client_.reset(
+      new aura::client::DefaultCaptureClient(host_->window()));
+
+  screen_position_client_.reset(new wm::DefaultScreenPositionClient);
+  aura::client::SetScreenPositionClient(host_->window(),
+                                        screen_position_client_.get());
+  dispatcher_client_.reset(new AndroidDispatcherClient);
+  aura::client::SetDispatcherClient(host_->window(), dispatcher_client_.get());
+
   // Aura needs to know which desktop (Ash or regular) will manage this widget.
   // See Widget::InitParams::context for details.
   DCHECK(params.parent || params.context);

[mfomitchev, 2015/11/06 16:45:50]

This seems wrong? This is top-level...

[bshe, 2015/11/11 00:38:30]

removed.

 
   ownership_ = params.ownership;
 
-  RegisterNativeWidgetForWindow(this, window_);
+  NativeWidgetAura::RegisterNativeWidgetForWindow(this, window_);
   window_->SetType(GetAuraWindowTypeForWidgetType(params.type));
   window_->SetProperty(aura::client::kShowStateKey, params.show_state);
   if (params.type == Widget::InitParams::TYPE_BUBBLE)
     aura::client::SetHideOnDeactivate(window_, true);
-  window_->SetTransparent(
-      params.opacity == Widget::InitParams::TRANSLUCENT_WINDOW);
+  window_->SetTransparent(params.opacity ==
+                          Widget::InitParams::TRANSLUCENT_WINDOW);
   window_->Init(params.layer_type);
   if (params.shadow_type == Widget::InitParams::SHADOW_TYPE_NONE)
     SetShadowType(window_, wm::SHADOW_TYPE_NONE);
   else if (params.shadow_type == Widget::InitParams::SHADOW_TYPE_DROP)
     SetShadowType(window_, wm::SHADOW_TYPE_RECTANGULAR);
   if (params.type == Widget::InitParams::TYPE_CONTROL)
     window_->Show();
 
   delegate_->OnNativeWidgetCreated(false);
 
   gfx::Rect window_bounds = params.bounds;
   gfx::NativeView parent = params.parent;

[mfomitchev, 2015/11/06 16:45:50]

Not sure if this code is appropriate for top-level widget.. Perhaps we should
use the code in DesktopNativeWidgetAura as a template here?

[bshe, 2015/11/11 00:38:30]

Right. Anything related to parent is probably not relevant here. I am a little
bit hesitate to use the code
in DesktopNativeWidgetAura though. It looks like DNWA use host_->window() in a
few places. But most
of our code only knows about window_(correspond to content_window_ in DNWA). I
worry there might be
some surprises. To reduce risk, I think remove unrelated code but still based on
NWA would be easier. WDYT?

   gfx::NativeView context = params.context;
   if (!params.child) {
     // Set up the transient child before the window is added. This way the
     // LayoutManager knows the window has a transient parent.
     if (parent && parent->type() != ui::wm::WINDOW_TYPE_UNKNOWN) {
       wm::AddTransientChild(parent, window_);
       if (!context)
         context = parent;
       parent = NULL;
     }
     // SetAlwaysOnTop before SetParent so that always-on-top container is used.
     SetAlwaysOnTop(params.keep_on_top);
     // Make sure we have a real |window_bounds|.
     if (parent && window_bounds == gfx::Rect()) {
       // If a parent is specified but no bounds are given,
       // use the origin of the parent's display so that the widget
       // will be added to the same display as the parent.
-      gfx::Rect bounds = gfx::Screen::GetScreenFor(parent)->
-          GetDisplayNearestWindow(parent).bounds();
+      gfx::Rect bounds = gfx::Screen::GetScreenFor(parent)
+                             ->GetDisplayNearestWindow(parent)
+                             .bounds();
       window_bounds.set_origin(bounds.origin());
     }
   }
 
   // Set properties before adding to the parent so that its layout manager sees
   // the correct values.
   OnSizeConstraintsChanged();
 
   if (parent) {
     parent->AddChild(window_);
   } else {
-    aura::client::ParentWindowWithContext(
-        window_, context->GetRootWindow(), window_bounds);
+    aura::client::ParentWindowWithContext(window_, context->GetRootWindow(),
+                                          window_bounds);
   }
 
   // Start observing property changes.
   window_->AddObserver(this);
 
   // Wait to set the bounds until we have a parent. That way we can know our
   // true state/bounds (the LayoutManager may enforce a particular
   // state/bounds).
   if (IsMaximized())
     SetRestoreBounds(window_, window_bounds);
   else
     SetBounds(window_bounds);
   window_->set_ignore_events(!params.accept_events);
   DCHECK(GetWidget()->GetRootView());
   if (params.type != Widget::InitParams::TYPE_TOOLTIP)
     tooltip_manager_.reset(new views::TooltipManagerAura(GetWidget()));
 
   drop_helper_.reset(new DropHelper(GetWidget()->GetRootView()));
   if (params.type != Widget::InitParams::TYPE_TOOLTIP &&
       params.type != Widget::InitParams::TYPE_POPUP) {
     aura::client::SetDragDropDelegate(window_, this);
   }
 
   aura::client::SetActivationDelegate(window_, this);
 
-  window_reorderer_.reset(new WindowReorderer(window_,
-      GetWidget()->GetRootView()));
+  window_reorderer_.reset(
+      new WindowReorderer(window_, GetWidget()->GetRootView()));
 }
 
-NonClientFrameView* NativeWidgetAura::CreateNonClientFrameView() {
+NonClientFrameView* NativeWidgetAndroid::CreateNonClientFrameView() {
   return NULL;

[mfomitchev, 2015/11/06 16:45:50]

previous impl was better IMHO

[bshe, 2015/11/11 00:38:30]

Done.

 }
 
-bool NativeWidgetAura::ShouldUseNativeFrame() const {
+bool NativeWidgetAndroid::ShouldUseNativeFrame() const {
   // There is only one frame type for aura.

[mfomitchev, 2015/11/06 16:45:50]

ditto

[bshe, 2015/11/11 00:38:30]

Done.

   return false;
 }
 
-bool NativeWidgetAura::ShouldWindowContentsBeTransparent() const {
+bool NativeWidgetAndroid::ShouldWindowContentsBeTransparent() const {
   return false;

[mfomitchev, 2015/11/06 16:45:51]

ditto

[bshe, 2015/11/11 00:38:30]

Done.

 }
 
-void NativeWidgetAura::FrameTypeChanged() {
+void NativeWidgetAndroid::FrameTypeChanged() {
   // This is called when the Theme has changed; forward the event to the root
   // widget.
   GetWidget()->ThemeChanged();

[mfomitchev, 2015/11/06 16:45:51]

We don't have themes.. maybe just leave NOTIMPLEMENTED since the frame-related
method is not implemented?

[bshe, 2015/11/11 00:38:30]

Done.

   GetWidget()->GetRootView()->SchedulePaint();
 }
 
-Widget* NativeWidgetAura::GetWidget() {
+Widget* NativeWidgetAndroid::GetWidget() {
   return delegate_->AsWidget();
 }
 
-const Widget* NativeWidgetAura::GetWidget() const {
+const Widget* NativeWidgetAndroid::GetWidget() const {
   return delegate_->AsWidget();
 }
 
-gfx::NativeView NativeWidgetAura::GetNativeView() const {
+gfx::NativeView NativeWidgetAndroid::GetNativeView() const {
   return window_;
 }
 
-gfx::NativeWindow NativeWidgetAura::GetNativeWindow() const {
+gfx::NativeWindow NativeWidgetAndroid::GetNativeWindow() const {
   return window_;
 }
 
-Widget* NativeWidgetAura::GetTopLevelWidget() {
+Widget* NativeWidgetAndroid::GetTopLevelWidget() {
   NativeWidgetPrivate* native_widget = GetTopLevelNativeWidget(GetNativeView());

[mfomitchev, 2015/11/06 16:45:51]

We are the top-level widget... use DNWA's impl?

[bshe, 2015/11/11 00:38:30]

Done.

   return native_widget ? native_widget->GetWidget() : NULL;
 }
 
-const ui::Compositor* NativeWidgetAura::GetCompositor() const {
+const ui::Compositor* NativeWidgetAndroid::GetCompositor() const {
   return window_ ? window_->layer()->GetCompositor() : NULL;

[mfomitchev, 2015/11/06 16:45:51]

Sadrul suggested host_->compositor()

[bshe, 2015/11/11 00:38:30]

Done.

 }
 
-const ui::Layer* NativeWidgetAura::GetLayer() const {
+const ui::Layer* NativeWidgetAndroid::GetLayer() const {
   return window_ ? window_->layer() : NULL;

[mfomitchev, 2015/11/06 16:45:51]

See Sadrul's comment

[bshe, 2015/11/11 00:38:29]

Done.

 }
 
-void NativeWidgetAura::ReorderNativeViews() {
+void NativeWidgetAndroid::ReorderNativeViews() {
   window_reorderer_->ReorderChildWindows();
 }
 
-void NativeWidgetAura::ViewRemoved(View* view) {
+void NativeWidgetAndroid::ViewRemoved(View* view) {
   DCHECK(drop_helper_.get() != NULL);

[mfomitchev, 2015/11/06 16:45:50]

We don't support DND, so NOTIMPLEMENTED() makes sense here

[bshe, 2015/11/11 00:38:30]

Done.

   drop_helper_->ResetTargetViewIfEquals(view);
 }
 
-void NativeWidgetAura::SetNativeWindowProperty(const char* name, void* value) {
+void NativeWidgetAndroid::SetNativeWindowProperty(const char* name,
+                                                  void* value) {
   if (window_)
     window_->SetNativeWindowProperty(name, value);
 }
 
-void* NativeWidgetAura::GetNativeWindowProperty(const char* name) const {
+void* NativeWidgetAndroid::GetNativeWindowProperty(const char* name) const {
   return window_ ? window_->GetNativeWindowProperty(name) : NULL;
 }
 
-TooltipManager* NativeWidgetAura::GetTooltipManager() const {
+TooltipManager* NativeWidgetAndroid::GetTooltipManager() const {
   return tooltip_manager_.get();
 }
 
-void NativeWidgetAura::SetCapture() {
+void NativeWidgetAndroid::SetCapture() {
   if (window_)
     window_->SetCapture();
 }
 
-void NativeWidgetAura::ReleaseCapture() {
+void NativeWidgetAndroid::ReleaseCapture() {
   if (window_)
     window_->ReleaseCapture();
 }
 
-bool NativeWidgetAura::HasCapture() const {
+bool NativeWidgetAndroid::HasCapture() const {
   return window_ && window_->HasCapture();
 }
 
-ui::InputMethod* NativeWidgetAura::GetInputMethod() {
+ui::InputMethod* NativeWidgetAndroid::GetInputMethod() {
   if (!window_)
     return nullptr;
   aura::Window* root_window = window_->GetRootWindow();
   return root_window ? root_window->GetHost()->GetInputMethod() : nullptr;
 }
 
-void NativeWidgetAura::CenterWindow(const gfx::Size& size) {
+void NativeWidgetAndroid::CenterWindow(const gfx::Size& size) {

[mfomitchev, 2015/11/06 16:45:51]

See my previous comment - not sure this makes sense since this is not designed
for top level. I think it makes sense to tackle this when we integrate with
native functionality for this.

[bshe, 2015/11/11 00:38:30]

Left a TODO and used NOTIMPLEMENTED for now.

   if (!window_)
     return;
 
   gfx::Rect parent_bounds(window_->parent()->GetBoundsInRootWindow());
   // When centering window, we take the intersection of the host and
   // the parent. We assume the root window represents the visible
   // rect of a single screen.
-  gfx::Rect work_area = gfx::Screen::GetScreenFor(window_)->
-      GetDisplayNearestWindow(window_).work_area();
+  gfx::Rect work_area = gfx::Screen::GetScreenFor(window_)
+                            ->GetDisplayNearestWindow(window_)
+                            .work_area();
 
   aura::client::ScreenPositionClient* screen_position_client =
       aura::client::GetScreenPositionClient(window_->GetRootWindow());
   if (screen_position_client) {
     gfx::Point origin = work_area.origin();
     screen_position_client->ConvertPointFromScreen(window_->GetRootWindow(),
                                                    &origin);
     work_area.set_origin(origin);
   }
 
   parent_bounds.Intersect(work_area);
 
   // If |window_|'s transient parent's bounds are big enough to fit it, then we
   // center it with respect to the transient parent.
   if (wm::GetTransientParent(window_)) {
     gfx::Rect transient_parent_rect =
         wm::GetTransientParent(window_)->GetBoundsInRootWindow();
     transient_parent_rect.Intersect(work_area);
     if (transient_parent_rect.height() >= size.height() &&
         transient_parent_rect.width() >= size.width())
       parent_bounds = transient_parent_rect;
   }
 
   gfx::Rect window_bounds(
       parent_bounds.x() + (parent_bounds.width() - size.width()) / 2,
       parent_bounds.y() + (parent_bounds.height() - size.height()) / 2,
-      size.width(),
-      size.height());
+      size.width(), size.height());
   // Don't size the window bigger than the parent, otherwise the user may not be
   // able to close or move it.
   window_bounds.AdjustToFit(parent_bounds);
 
   // Convert the bounds back relative to the parent.
   gfx::Point origin = window_bounds.origin();
   aura::Window::ConvertPointToTarget(window_->GetRootWindow(),
-      window_->parent(), &origin);
+                                     window_->parent(), &origin);
   window_bounds.set_origin(origin);
   window_->SetBounds(window_bounds);
 }
 
-void NativeWidgetAura::GetWindowPlacement(
+void NativeWidgetAndroid::GetWindowPlacement(
     gfx::Rect* bounds,
     ui::WindowShowState* show_state) const {
   // The interface specifies returning restored bounds, not current bounds.

[mfomitchev, 2015/11/06 16:45:51]

ditto

[bshe, 2015/11/11 00:38:30]

Done.

   *bounds = GetRestoredBounds();
-  *show_state = window_ ? window_->GetProperty(aura::client::kShowStateKey) :
-      ui::SHOW_STATE_DEFAULT;
+  *show_state = window_ ? window_->GetProperty(aura::client::kShowStateKey)
+                        : ui::SHOW_STATE_DEFAULT;
 }
 
-bool NativeWidgetAura::SetWindowTitle(const base::string16& title) {
+bool NativeWidgetAndroid::SetWindowTitle(const base::string16& title) {
   if (!window_)

[mfomitchev, 2015/11/06 16:45:51]

window_ can't be null?

[bshe, 2015/11/11 00:38:30]

Done.

     return false;
   if (window_->title() == title)
     return false;
   window_->SetTitle(title);
   return true;
 }
 
-void NativeWidgetAura::SetWindowIcons(const gfx::ImageSkia& window_icon,
-                                      const gfx::ImageSkia& app_icon) {
+void NativeWidgetAndroid::SetWindowIcons(const gfx::ImageSkia& window_icon,
+                                         const gfx::ImageSkia& app_icon) {
   // Aura doesn't have window icons.

[mfomitchev, 2015/11/06 16:45:50]

DesktopNativeWidgetAura has something for this, so NOTIMPLEMENTED() might make
more sense? Not really sure

[bshe, 2015/11/11 00:38:30]

Done.

 }
 
-void NativeWidgetAura::InitModalType(ui::ModalType modal_type) {
+void NativeWidgetAndroid::InitModalType(ui::ModalType modal_type) {
   if (modal_type != ui::MODAL_TYPE_NONE)
     window_->SetProperty(aura::client::kModalKey, modal_type);
 }
 
-gfx::Rect NativeWidgetAura::GetWindowBoundsInScreen() const {
+gfx::Rect NativeWidgetAndroid::GetWindowBoundsInScreen() const {
   return window_ ? window_->GetBoundsInScreen() : gfx::Rect();
 }
 
-gfx::Rect NativeWidgetAura::GetClientAreaBoundsInScreen() const {
+gfx::Rect NativeWidgetAndroid::GetClientAreaBoundsInScreen() const {
   // View-to-screen coordinate system transformations depend on this returning
   // the full window bounds, for example View::ConvertPointToScreen().
   return window_ ? window_->GetBoundsInScreen() : gfx::Rect();
 }
 
-gfx::Rect NativeWidgetAura::GetRestoredBounds() const {
+gfx::Rect NativeWidgetAndroid::GetRestoredBounds() const {
   if (!window_)

[mfomitchev, 2015/11/06 16:45:50]

Same as CenterWindow and other top-level sizing/positioning

[bshe, 2015/11/11 00:38:30]

Done.

     return gfx::Rect();
 
   // Restored bounds should only be relevant if the window is minimized,
   // maximized, fullscreen or docked. However, in some places the code expects
   // GetRestoredBounds() to return the current window bounds if the window is
   // not in either state.
   if (IsMinimized() || IsMaximized() || IsFullscreen()) {
     // Restore bounds are in screen coordinates, no need to convert.
     gfx::Rect* restore_bounds =
         window_->GetProperty(aura::client::kRestoreBoundsKey);
     if (restore_bounds)
       return *restore_bounds;
   }
   gfx::Rect bounds = window_->GetBoundsInScreen();
   if (IsDocked()) {
     // Restore bounds are in screen coordinates, no need to convert.
     gfx::Rect* restore_bounds =
         window_->GetProperty(aura::client::kRestoreBoundsKey);
     // Use current window horizontal offset origin in order to preserve docked
     // alignment but preserve restored size and vertical offset for the time
     // when the |window_| gets undocked.
     if (restore_bounds) {
       bounds.set_size(restore_bounds->size());
       bounds.set_y(restore_bounds->y());
     }
   }
   return bounds;
 }
 
-void NativeWidgetAura::SetBounds(const gfx::Rect& bounds) {
+void NativeWidgetAndroid::SetBounds(const gfx::Rect& bounds) {
   if (!window_)
     return;
 
   aura::Window* root = window_->GetRootWindow();
   if (root) {
     aura::client::ScreenPositionClient* screen_position_client =
         aura::client::GetScreenPositionClient(root);
     if (screen_position_client) {
       gfx::Display dst_display =
           gfx::Screen::GetScreenFor(window_)->GetDisplayMatching(bounds);
       screen_position_client->SetBounds(window_, bounds, dst_display);
       return;
     }
   }
   window_->SetBounds(bounds);
 }
 
-void NativeWidgetAura::SetSize(const gfx::Size& size) {
+void NativeWidgetAndroid::SetSize(const gfx::Size& size) {
   if (window_)
     window_->SetBounds(gfx::Rect(window_->bounds().origin(), size));
 }
 
-void NativeWidgetAura::StackAbove(gfx::NativeView native_view) {
+void NativeWidgetAndroid::StackAbove(gfx::NativeView native_view) {
   if (window_ && window_->parent() &&
       window_->parent() == native_view->parent())
     window_->parent()->StackChildAbove(window_, native_view);
 }
 
-void NativeWidgetAura::StackAtTop() {
+void NativeWidgetAndroid::StackAtTop() {
   if (window_)
     window_->parent()->StackChildAtTop(window_);
 }
 
-void NativeWidgetAura::StackBelow(gfx::NativeView native_view) {
+void NativeWidgetAndroid::StackBelow(gfx::NativeView native_view) {
   if (window_ && window_->parent() &&
       window_->parent() == native_view->parent())
     window_->parent()->StackChildBelow(window_, native_view);
 }
 
-void NativeWidgetAura::SetShape(SkRegion* region) {
+void NativeWidgetAndroid::SetShape(SkRegion* region) {
   if (window_)
     window_->layer()->SetAlphaShape(make_scoped_ptr(region));
   else
     delete region;
 }
 
-void NativeWidgetAura::Close() {
+void NativeWidgetAndroid::Close() {
   // |window_| may already be deleted by parent window. This can happen
   // when this widget is child widget or has transient parent
   // and ownership is WIDGET_OWNS_NATIVE_WIDGET.
   DCHECK(window_ ||
          ownership_ == Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
   if (window_) {
     window_->SuppressPaint();
     Hide();
     window_->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_NONE);
   }
 
   if (!close_widget_factory_.HasWeakPtrs()) {
     base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&NativeWidgetAura::CloseNow,
-                   close_widget_factory_.GetWeakPtr()));
+        FROM_HERE, base::Bind(&NativeWidgetAndroid::CloseNow,
+                              close_widget_factory_.GetWeakPtr()));
   }
 }
 
-void NativeWidgetAura::CloseNow() {
+void NativeWidgetAndroid::CloseNow() {
   delete window_;

[mfomitchev, 2015/11/06 16:45:51]

see Sadrul's comment

[bshe, 2015/11/11 00:38:30]

Done.

 }
 
-void NativeWidgetAura::Show() {
+void NativeWidgetAndroid::Show() {
   ShowWithWindowState(ui::SHOW_STATE_NORMAL);
 }
 
-void NativeWidgetAura::Hide() {
+void NativeWidgetAndroid::Hide() {
   if (window_)
     window_->Hide();
 }
 
-void NativeWidgetAura::ShowMaximizedWithBounds(
+void NativeWidgetAndroid::ShowMaximizedWithBounds(
     const gfx::Rect& restored_bounds) {
   SetRestoreBounds(window_, restored_bounds);
   ShowWithWindowState(ui::SHOW_STATE_MAXIMIZED);
 }
 
-void NativeWidgetAura::ShowWithWindowState(ui::WindowShowState state) {
+void NativeWidgetAndroid::ShowWithWindowState(ui::WindowShowState state) {
   if (!window_)
     return;
 
   if (state == ui::SHOW_STATE_MAXIMIZED || state == ui::SHOW_STATE_FULLSCREEN ||
       state == ui::SHOW_STATE_DOCKED) {
     window_->SetProperty(aura::client::kShowStateKey, state);
   }
   window_->Show();
   if (delegate_->CanActivate()) {
     if (state != ui::SHOW_STATE_INACTIVE)
       Activate();
     // SetInitialFocus() should be always be called, even for
     // SHOW_STATE_INACTIVE. If the window has to stay inactive, the method will
     // do the right thing.
     SetInitialFocus(state);
   }
 }
 
-bool NativeWidgetAura::IsVisible() const {
+bool NativeWidgetAndroid::IsVisible() const {
   return window_ && window_->IsVisible();
 }
 
-void NativeWidgetAura::Activate() {
+void NativeWidgetAndroid::Activate() {
   if (!window_)
     return;
 
   // We don't necessarily have a root window yet. This can happen with
   // constrained windows.
   if (window_->GetRootWindow()) {
-    aura::client::GetActivationClient(window_->GetRootWindow())->ActivateWindow(
-        window_);
+    aura::client::GetActivationClient(window_->GetRootWindow())
+        ->ActivateWindow(window_);
   }
   if (window_->GetProperty(aura::client::kDrawAttentionKey))
     window_->SetProperty(aura::client::kDrawAttentionKey, false);
 }
 
-void NativeWidgetAura::Deactivate() {
+void NativeWidgetAndroid::Deactivate() {
   if (!window_)
     return;
-  aura::client::GetActivationClient(window_->GetRootWindow())->DeactivateWindow(
-      window_);
+  aura::client::GetActivationClient(window_->GetRootWindow())
+      ->DeactivateWindow(window_);
 }
 
-bool NativeWidgetAura::IsActive() const {
+bool NativeWidgetAndroid::IsActive() const {
   return window_ && wm::IsActiveWindow(window_);
 }
 
-void NativeWidgetAura::SetAlwaysOnTop(bool on_top) {
+void NativeWidgetAndroid::SetAlwaysOnTop(bool on_top) {
   if (window_)
     window_->SetProperty(aura::client::kAlwaysOnTopKey, on_top);
 }
 
-bool NativeWidgetAura::IsAlwaysOnTop() const {
+bool NativeWidgetAndroid::IsAlwaysOnTop() const {
   return window_ && window_->GetProperty(aura::client::kAlwaysOnTopKey);
 }
 
-void NativeWidgetAura::SetVisibleOnAllWorkspaces(bool always_visible) {
+void NativeWidgetAndroid::SetVisibleOnAllWorkspaces(bool always_visible) {
   // Not implemented on chromeos or for child widgets.
 }
 
-void NativeWidgetAura::Maximize() {
+void NativeWidgetAndroid::Maximize() {
   if (window_)
     window_->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
 }
 
-void NativeWidgetAura::Minimize() {
+void NativeWidgetAndroid::Minimize() {
   if (window_)
     window_->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
 }
 
-bool NativeWidgetAura::IsMaximized() const {
-  return window_ && window_->GetProperty(aura::client::kShowStateKey) ==
-      ui::SHOW_STATE_MAXIMIZED;
+bool NativeWidgetAndroid::IsMaximized() const {
+  return window_ &&
+         window_->GetProperty(aura::client::kShowStateKey) ==
+             ui::SHOW_STATE_MAXIMIZED;
 }
 
-bool NativeWidgetAura::IsMinimized() const {
-  return window_ && window_->GetProperty(aura::client::kShowStateKey) ==
-      ui::SHOW_STATE_MINIMIZED;
+bool NativeWidgetAndroid::IsMinimized() const {
+  return window_ &&
+         window_->GetProperty(aura::client::kShowStateKey) ==
+             ui::SHOW_STATE_MINIMIZED;
 }
 
-void NativeWidgetAura::Restore() {
+void NativeWidgetAndroid::Restore() {
   if (window_)
     window_->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
 }
 
-void NativeWidgetAura::SetFullscreen(bool fullscreen) {
+void NativeWidgetAndroid::SetFullscreen(bool fullscreen) {
   if (!window_ || IsFullscreen() == fullscreen)
     return;  // Nothing to do.
 
   // Save window state before entering full screen so that it could restored
   // when exiting full screen.
   if (fullscreen)
     saved_window_state_ = window_->GetProperty(aura::client::kShowStateKey);
 
   window_->SetProperty(
       aura::client::kShowStateKey,
       fullscreen ? ui::SHOW_STATE_FULLSCREEN : saved_window_state_);
 }
 
-bool NativeWidgetAura::IsFullscreen() const {
-  return window_ && window_->GetProperty(aura::client::kShowStateKey) ==
-      ui::SHOW_STATE_FULLSCREEN;
+bool NativeWidgetAndroid::IsFullscreen() const {
+  return window_ &&
+         window_->GetProperty(aura::client::kShowStateKey) ==
+             ui::SHOW_STATE_FULLSCREEN;
 }
 
-void NativeWidgetAura::SetOpacity(unsigned char opacity) {
+void NativeWidgetAndroid::SetOpacity(unsigned char opacity) {
   if (window_)
     window_->layer()->SetOpacity(opacity / 255.0);
 }
 
-void NativeWidgetAura::SetUseDragFrame(bool use_drag_frame) {
+void NativeWidgetAndroid::SetUseDragFrame(bool use_drag_frame) {
   NOTIMPLEMENTED();
 }
 
-void NativeWidgetAura::FlashFrame(bool flash) {
+void NativeWidgetAndroid::FlashFrame(bool flash) {
   if (window_)
     window_->SetProperty(aura::client::kDrawAttentionKey, flash);
 }
 
-void NativeWidgetAura::RunShellDrag(View* view,
-                                    const ui::OSExchangeData& data,
-                                    const gfx::Point& location,
-                                    int operation,
-                                    ui::DragDropTypes::DragEventSource source) {
+void NativeWidgetAndroid::RunShellDrag(
+    View* view,
+    const ui::OSExchangeData& data,
+    const gfx::Point& location,
+    int operation,
+    ui::DragDropTypes::DragEventSource source) {
   if (window_)
     views::RunShellDrag(window_, data, location, operation, source);
 }
 
-void NativeWidgetAura::SchedulePaintInRect(const gfx::Rect& rect) {
+void NativeWidgetAndroid::SchedulePaintInRect(const gfx::Rect& rect) {
   if (window_)
     window_->SchedulePaintInRect(rect);
 }
 
-void NativeWidgetAura::SetCursor(gfx::NativeCursor cursor) {
+void NativeWidgetAndroid::SetCursor(gfx::NativeCursor cursor) {
   cursor_ = cursor;
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(window_->GetRootWindow());
   if (cursor_client)
     cursor_client->SetCursor(cursor);
 }
 
-bool NativeWidgetAura::IsMouseEventsEnabled() const {
+bool NativeWidgetAndroid::IsMouseEventsEnabled() const {
   if (!window_)
     return false;
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(window_->GetRootWindow());
   return cursor_client ? cursor_client->IsMouseEventsEnabled() : true;
 }
 
-void NativeWidgetAura::ClearNativeFocus() {
+void NativeWidgetAndroid::ClearNativeFocus() {
   aura::client::FocusClient* client = aura::client::GetFocusClient(window_);
   if (window_ && client && window_->Contains(client->GetFocusedWindow()))
     client->ResetFocusWithinActiveWindow(window_);
 }
 
-gfx::Rect NativeWidgetAura::GetWorkAreaBoundsInScreen() const {
+gfx::Rect NativeWidgetAndroid::GetWorkAreaBoundsInScreen() const {
   if (!window_)
     return gfx::Rect();
-  return gfx::Screen::GetScreenFor(window_)->
-      GetDisplayNearestWindow(window_).work_area();
+  return gfx::Screen::GetScreenFor(window_)
+      ->GetDisplayNearestWindow(window_)
+      .work_area();
 }
 
-Widget::MoveLoopResult NativeWidgetAura::RunMoveLoop(
+Widget::MoveLoopResult NativeWidgetAndroid::RunMoveLoop(
     const gfx::Vector2d& drag_offset,
     Widget::MoveLoopSource source,
     Widget::MoveLoopEscapeBehavior escape_behavior) {
   // |escape_behavior| is only needed on windows when running the native message
   // loop.
   if (!window_ || !window_->GetRootWindow())
     return Widget::MOVE_LOOP_CANCELED;
   aura::client::WindowMoveClient* move_client =
       aura::client::GetWindowMoveClient(window_->GetRootWindow());
   if (!move_client)
     return Widget::MOVE_LOOP_CANCELED;
 
   SetCapture();
   aura::client::WindowMoveSource window_move_source =
-      source == Widget::MOVE_LOOP_SOURCE_MOUSE ?
-      aura::client::WINDOW_MOVE_SOURCE_MOUSE :
-      aura::client::WINDOW_MOVE_SOURCE_TOUCH;
+      source == Widget::MOVE_LOOP_SOURCE_MOUSE
+          ? aura::client::WINDOW_MOVE_SOURCE_MOUSE
+          : aura::client::WINDOW_MOVE_SOURCE_TOUCH;
   if (move_client->RunMoveLoop(window_, drag_offset, window_move_source) ==
-          aura::client::MOVE_SUCCESSFUL) {
+      aura::client::MOVE_SUCCESSFUL) {
     return Widget::MOVE_LOOP_SUCCESSFUL;
   }
   return Widget::MOVE_LOOP_CANCELED;
 }
 
-void NativeWidgetAura::EndMoveLoop() {
+void NativeWidgetAndroid::EndMoveLoop() {
   if (!window_ || !window_->GetRootWindow())
     return;
   aura::client::WindowMoveClient* move_client =
       aura::client::GetWindowMoveClient(window_->GetRootWindow());
   if (move_client)
     move_client->EndMoveLoop();
 }
 
-void NativeWidgetAura::SetVisibilityChangedAnimationsEnabled(bool value) {
+void NativeWidgetAndroid::SetVisibilityChangedAnimationsEnabled(bool value) {
   if (window_)
     window_->SetProperty(aura::client::kAnimationsDisabledKey, !value);
 }
 
-void NativeWidgetAura::SetVisibilityAnimationDuration(
+void NativeWidgetAndroid::SetVisibilityAnimationDuration(
     const base::TimeDelta& duration) {
   wm::SetWindowVisibilityAnimationDuration(window_, duration);
 }
 
-void NativeWidgetAura::SetVisibilityAnimationTransition(
+void NativeWidgetAndroid::SetVisibilityAnimationTransition(
     Widget::VisibilityTransition transition) {
   wm::WindowVisibilityAnimationTransition wm_transition = wm::ANIMATE_NONE;
   switch (transition) {
     case Widget::ANIMATE_SHOW:
       wm_transition = wm::ANIMATE_SHOW;
       break;
     case Widget::ANIMATE_HIDE:
       wm_transition = wm::ANIMATE_HIDE;
       break;
     case Widget::ANIMATE_BOTH:
       wm_transition = wm::ANIMATE_BOTH;
       break;
     case Widget::ANIMATE_NONE:
       wm_transition = wm::ANIMATE_NONE;
       break;
   }
   wm::SetWindowVisibilityAnimationTransition(window_, wm_transition);
 }
 
-ui::NativeTheme* NativeWidgetAura::GetNativeTheme() const {
-#if !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
-  return DesktopWindowTreeHost::GetNativeTheme(window_);
-#else
+ui::NativeTheme* NativeWidgetAndroid::GetNativeTheme() const {
   return ui::NativeThemeAura::instance();
-#endif
 }
 
-void NativeWidgetAura::OnRootViewLayout() {
-}
+void NativeWidgetAndroid::OnRootViewLayout() {}
 
-bool NativeWidgetAura::IsTranslucentWindowOpacitySupported() const {
+bool NativeWidgetAndroid::IsTranslucentWindowOpacitySupported() const {
   return true;
 }
 
-void NativeWidgetAura::OnSizeConstraintsChanged() {
+void NativeWidgetAndroid::OnSizeConstraintsChanged() {
   window_->SetProperty(aura::client::kCanMaximizeKey,
                        GetWidget()->widget_delegate()->CanMaximize());
   window_->SetProperty(aura::client::kCanMinimizeKey,
                        GetWidget()->widget_delegate()->CanMinimize());
   window_->SetProperty(aura::client::kCanResizeKey,
                        GetWidget()->widget_delegate()->CanResize());
 }
 
-void NativeWidgetAura::RepostNativeEvent(gfx::NativeEvent native_event) {
+void NativeWidgetAndroid::RepostNativeEvent(gfx::NativeEvent native_event) {
   OnEvent(native_event);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetAura, aura::WindowDelegate implementation:
+// NativeWidgetAndroid, aura::WindowDelegate implementation:
 
-gfx::Size NativeWidgetAura::GetMinimumSize() const {
+gfx::Size NativeWidgetAndroid::GetMinimumSize() const {
   return delegate_->GetMinimumSize();
 }
 
-gfx::Size NativeWidgetAura::GetMaximumSize() const {
+gfx::Size NativeWidgetAndroid::GetMaximumSize() const {
   // If a window have a maximum size, the window should not be
   // maximizable.
   DCHECK(delegate_->GetMaximumSize().IsEmpty() ||
          !window_->GetProperty(aura::client::kCanMaximizeKey));
   return delegate_->GetMaximumSize();
 }
 
-void NativeWidgetAura::OnBoundsChanged(const gfx::Rect& old_bounds,
-                                       const gfx::Rect& new_bounds) {
+void NativeWidgetAndroid::OnBoundsChanged(const gfx::Rect& old_bounds,
+                                          const gfx::Rect& new_bounds) {
   // Assume that if the old bounds was completely empty a move happened. This
   // handles the case of a maximize animation acquiring the layer (acquiring a
   // layer results in clearing the bounds).
   if (old_bounds.origin() != new_bounds.origin() ||
       (old_bounds == gfx::Rect(0, 0, 0, 0) && !new_bounds.IsEmpty())) {
     delegate_->OnNativeWidgetMove();
   }
   if (old_bounds.size() != new_bounds.size())
     delegate_->OnNativeWidgetSizeChanged(new_bounds.size());
 }
 
-gfx::NativeCursor NativeWidgetAura::GetCursor(const gfx::Point& point) {
+gfx::NativeCursor NativeWidgetAndroid::GetCursor(const gfx::Point& point) {
   return cursor_;
 }
 
-int NativeWidgetAura::GetNonClientComponent(const gfx::Point& point) const {
+int NativeWidgetAndroid::GetNonClientComponent(const gfx::Point& point) const {
   return delegate_->GetNonClientComponent(point);
 }
 
-bool NativeWidgetAura::ShouldDescendIntoChildForEventHandling(
-      aura::Window* child,
-      const gfx::Point& location) {
+bool NativeWidgetAndroid::ShouldDescendIntoChildForEventHandling(
+    aura::Window* child,
+    const gfx::Point& location) {
   views::WidgetDelegate* widget_delegate = GetWidget()->widget_delegate();
   if (widget_delegate &&
       !widget_delegate->ShouldDescendIntoChildForEventHandling(child, location))
     return false;
 
   // Don't descend into |child| if there is a view with a Layer that contains
   // the point and is stacked above |child|s layer.
   typedef std::vector<ui::Layer*> Layers;
   const Layers& root_layers(delegate_->GetRootLayers());
   if (root_layers.empty())
@@ skipping 12 matching lines @@
       Layers::const_iterator root_layer_iter(
           std::find(window_->layer()->children().begin(),
                     window_->layer()->children().end(), layer));
       if (root_layer_iter > child_layer_iter)
         return false;
     }
   }
   return true;
 }
 
-bool NativeWidgetAura::CanFocus() {
+bool NativeWidgetAndroid::CanFocus() {
   return ShouldActivate();
 }
 
-void NativeWidgetAura::OnCaptureLost() {
+void NativeWidgetAndroid::OnCaptureLost() {
   delegate_->OnMouseCaptureLost();
 }
 
-void NativeWidgetAura::OnPaint(const ui::PaintContext& context) {
+void NativeWidgetAndroid::OnPaint(const ui::PaintContext& context) {
   delegate_->OnNativeWidgetPaint(context);
 }
 
-void NativeWidgetAura::OnDeviceScaleFactorChanged(float device_scale_factor) {
+void NativeWidgetAndroid::OnDeviceScaleFactorChanged(
+    float device_scale_factor) {
   GetWidget()->DeviceScaleFactorChanged(device_scale_factor);
 }
 
-void NativeWidgetAura::OnWindowDestroying(aura::Window* window) {
+void NativeWidgetAndroid::OnWindowDestroying(aura::Window* window) {
   window_->RemoveObserver(this);
   delegate_->OnNativeWidgetDestroying();
 
   // If the aura::Window is destroyed, we can no longer show tooltips.
   tooltip_manager_.reset();
 }
 
-void NativeWidgetAura::OnWindowDestroyed(aura::Window* window) {
+void NativeWidgetAndroid::OnWindowDestroyed(aura::Window* window) {
   window_ = NULL;
   delegate_->OnNativeWidgetDestroyed();
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
     delete this;
 }
 
-void NativeWidgetAura::OnWindowTargetVisibilityChanged(bool visible) {
+void NativeWidgetAndroid::OnWindowTargetVisibilityChanged(bool visible) {
   delegate_->OnNativeWidgetVisibilityChanged(visible);
 }
 
-bool NativeWidgetAura::HasHitTestMask() const {
+bool NativeWidgetAndroid::HasHitTestMask() const {
   return delegate_->HasHitTestMask();
 }
 
-void NativeWidgetAura::GetHitTestMask(gfx::Path* mask) const {
+void NativeWidgetAndroid::GetHitTestMask(gfx::Path* mask) const {
   DCHECK(mask);
   delegate_->GetHitTestMask(mask);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetAura, aura::WindowObserver implementation:
+// NativeWidgetAndroid, aura::WindowObserver implementation:
 
-void NativeWidgetAura::OnWindowPropertyChanged(aura::Window* window,
-                                               const void* key,
-                                               intptr_t old) {
+void NativeWidgetAndroid::OnWindowPropertyChanged(aura::Window* window,
+                                                  const void* key,
+                                                  intptr_t old) {
   if (key == aura::client::kShowStateKey)
     delegate_->OnNativeWidgetWindowShowStateChanged();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetAura, ui::EventHandler implementation:
+// NativeWidgetAndroid, ui::EventHandler implementation:
 
-void NativeWidgetAura::OnKeyEvent(ui::KeyEvent* event) {
+void NativeWidgetAndroid::OnKeyEvent(ui::KeyEvent* event) {
   DCHECK(window_);
   // Renderer may send a key event back to us if the key event wasn't handled,
   // and the window may be invisible by that time.
   if (!window_->IsVisible())
     return;
 
   FocusManager* focus_manager = GetWidget()->GetFocusManager();
   delegate_->OnKeyEvent(event);
   if (!event->handled() && focus_manager)
     focus_manager->OnKeyEvent(*event);
   event->SetHandled();
 }
 
-void NativeWidgetAura::OnMouseEvent(ui::MouseEvent* event) {
+void NativeWidgetAndroid::OnMouseEvent(ui::MouseEvent* event) {
   DCHECK(window_);
   DCHECK(window_->IsVisible());
   if (event->type() == ui::ET_MOUSEWHEEL) {
     delegate_->OnMouseEvent(event);
     if (event->handled())
       return;
   }
 
   if (tooltip_manager_.get())
     tooltip_manager_->UpdateTooltip();
   TooltipManagerAura::UpdateTooltipManagerForCapture(GetWidget());
   delegate_->OnMouseEvent(event);
 }
 
-void NativeWidgetAura::OnScrollEvent(ui::ScrollEvent* event) {
+void NativeWidgetAndroid::OnScrollEvent(ui::ScrollEvent* event) {
   delegate_->OnScrollEvent(event);
 }
 
-void NativeWidgetAura::OnGestureEvent(ui::GestureEvent* event) {
+void NativeWidgetAndroid::OnGestureEvent(ui::GestureEvent* event) {
   DCHECK(window_);
   DCHECK(window_->IsVisible() || event->IsEndingEvent());
   delegate_->OnGestureEvent(event);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetAura, aura::client::ActivationDelegate implementation:
+// NativeWidgetAndroid, aura::client::ActivationDelegate implementation:
 
-bool NativeWidgetAura::ShouldActivate() const {
+bool NativeWidgetAndroid::ShouldActivate() const {
   return delegate_->CanActivate();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetAura, aura::client::ActivationChangeObserver implementation:
+// NativeWidgetAndroid, aura::client::ActivationChangeObserver implementation:
 
-void NativeWidgetAura::OnWindowActivated(
+void NativeWidgetAndroid::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   DCHECK(window_ == gained_active || window_ == lost_active);
   if (GetWidget()->GetFocusManager()) {
     if (window_ == gained_active)
       GetWidget()->GetFocusManager()->RestoreFocusedView();
     else if (window_ == lost_active)
       GetWidget()->GetFocusManager()->StoreFocusedView(true);
   }
   delegate_->OnNativeWidgetActivationChanged(window_ == gained_active);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetAura, aura::client::FocusChangeObserver:
+// NativeWidgetAndroid, aura::client::FocusChangeObserver:
 
-void NativeWidgetAura::OnWindowFocused(aura::Window* gained_focus,
-                                       aura::Window* lost_focus) {
+void NativeWidgetAndroid::OnWindowFocused(aura::Window* gained_focus,
+                                          aura::Window* lost_focus) {
   if (window_ == gained_focus)
     delegate_->OnNativeFocus();
   else if (window_ == lost_focus)
     delegate_->OnNativeBlur();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetAura, aura::WindowDragDropDelegate implementation:
+// NativeWidgetAndroid, aura::WindowDragDropDelegate implementation:
 
-void NativeWidgetAura::OnDragEntered(const ui::DropTargetEvent& event) {
+void NativeWidgetAndroid::OnDragEntered(const ui::DropTargetEvent& event) {
   DCHECK(drop_helper_.get() != NULL);
-  last_drop_operation_ = drop_helper_->OnDragOver(event.data(),
-      event.location(), event.source_operations());
+  last_drop_operation_ = drop_helper_->OnDragOver(
+      event.data(), event.location(), event.source_operations());
 }
 
-int NativeWidgetAura::OnDragUpdated(const ui::DropTargetEvent& event) {
+int NativeWidgetAndroid::OnDragUpdated(const ui::DropTargetEvent& event) {
   DCHECK(drop_helper_.get() != NULL);
-  last_drop_operation_ = drop_helper_->OnDragOver(event.data(),
-      event.location(), event.source_operations());
+  last_drop_operation_ = drop_helper_->OnDragOver(
+      event.data(), event.location(), event.source_operations());
   return last_drop_operation_;
 }
 
-void NativeWidgetAura::OnDragExited() {
+void NativeWidgetAndroid::OnDragExited() {
   DCHECK(drop_helper_.get() != NULL);
   drop_helper_->OnDragExit();
 }
 
-int NativeWidgetAura::OnPerformDrop(const ui::DropTargetEvent& event) {
+int NativeWidgetAndroid::OnPerformDrop(const ui::DropTargetEvent& event) {
   DCHECK(drop_helper_.get() != NULL);
   return drop_helper_->OnDrop(event.data(), event.location(),
-      last_drop_operation_);
+                              last_drop_operation_);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetAura, protected:
+// NativeWidgetAndroid, protected:
 
-NativeWidgetAura::~NativeWidgetAura() {
+NativeWidgetAndroid::~NativeWidgetAndroid() {
   destroying_ = true;
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
     delete delegate_;
   else
     CloseNow();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// NativeWidgetAura, private:
+// NativeWidgetAndroid, private:
 
-bool NativeWidgetAura::IsDocked() const {
+bool NativeWidgetAndroid::IsDocked() const {
   return window_ &&
          window_->GetProperty(aura::client::kShowStateKey) ==
              ui::SHOW_STATE_DOCKED;
 }
 
-void NativeWidgetAura::SetInitialFocus(ui::WindowShowState show_state) {
+void NativeWidgetAndroid::SetInitialFocus(ui::WindowShowState show_state) {
   // The window does not get keyboard messages unless we focus it.
   if (!GetWidget()->SetInitialFocus(show_state))
     window_->Focus();
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// Widget, public:
-
-namespace {
-#if defined(OS_WIN) || (defined(USE_X11) && !defined(OS_CHROMEOS))
-void CloseWindow(aura::Window* window) {
-  if (window) {
-    Widget* widget = Widget::GetWidgetForNativeView(window);
-    if (widget && widget->is_secondary_widget())
-      // To avoid the delay in shutdown caused by using Close which may wait
-      // for animations, use CloseNow. Because this is only used on secondary
-      // widgets it seems relatively safe to skip the extra processing of
-      // Close.
-      widget->CloseNow();
-  }
-}
-#endif
-
-#if defined(OS_WIN)
-BOOL CALLBACK WindowCallbackProc(HWND hwnd, LPARAM lParam) {
-  aura::Window* root_window =
-      DesktopWindowTreeHostWin::GetContentWindowForHWND(hwnd);
-  CloseWindow(root_window);
-  return TRUE;
-}
-#endif
-}  // namespace
-
-// static
-void Widget::CloseAllSecondaryWidgets() {
-#if defined(OS_WIN)
-  EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc, 0);
-#endif
-
-#if defined(USE_X11) && !defined(OS_CHROMEOS)
-  DesktopWindowTreeHostX11::CleanUpWindowList(CloseWindow);
-#endif
-}
-
-bool Widget::ConvertRect(const Widget* source,
-                         const Widget* target,
-                         gfx::Rect* rect) {
-  return false;
-}
-
-namespace internal {
-
-////////////////////////////////////////////////////////////////////////////////
-// internal::NativeWidgetPrivate, public:
-
-// static
-NativeWidgetPrivate* NativeWidgetPrivate::CreateNativeWidget(
-    internal::NativeWidgetDelegate* delegate) {
-  return new NativeWidgetAura(delegate);
-}
-
-// static
-NativeWidgetPrivate* NativeWidgetPrivate::GetNativeWidgetForNativeView(
-    gfx::NativeView native_view) {
-  // Cast must match type supplied to RegisterNativeWidgetForWindow().
-  return reinterpret_cast<NativeWidgetPrivate*>(native_view->user_data());
-}
-
-// static
-NativeWidgetPrivate* NativeWidgetPrivate::GetNativeWidgetForNativeWindow(
-    gfx::NativeWindow native_window) {
-  // Cast must match type supplied to RegisterNativeWidgetForWindow().
-  return reinterpret_cast<NativeWidgetPrivate*>(native_window->user_data());
-}
-
-// static
-NativeWidgetPrivate* NativeWidgetPrivate::GetTopLevelNativeWidget(
-    gfx::NativeView native_view) {
-  aura::Window* window = native_view;
-  NativeWidgetPrivate* top_level_native_widget = NULL;
-  while (window) {
-    NativeWidgetPrivate* native_widget = GetNativeWidgetForNativeView(window);
-    if (native_widget)
-      top_level_native_widget = native_widget;
-    window = window->parent();
-  }
-  return top_level_native_widget;
-}
-
-// static
-void NativeWidgetPrivate::GetAllChildWidgets(gfx::NativeView native_view,
-                                             Widget::Widgets* children) {
-  {
-    // Code expects widget for |native_view| to be added to |children|.
-    NativeWidgetPrivate* native_widget = static_cast<NativeWidgetPrivate*>(
-        GetNativeWidgetForNativeView(native_view));
-    if (native_widget && native_widget->GetWidget())
-      children->insert(native_widget->GetWidget());
-  }
-
-  const aura::Window::Windows& child_windows = native_view->children();
-  for (aura::Window::Windows::const_iterator i = child_windows.begin();
-       i != child_windows.end(); ++i) {
-    GetAllChildWidgets((*i), children);
-  }
-}
-
-// static
-void NativeWidgetPrivate::GetAllOwnedWidgets(gfx::NativeView native_view,
-                                             Widget::Widgets* owned) {
-  // Add all owned widgets.
-  for (aura::Window* transient_child : wm::GetTransientChildren(native_view)) {
-    NativeWidgetPrivate* native_widget = static_cast<NativeWidgetPrivate*>(
-        GetNativeWidgetForNativeView(transient_child));
-    if (native_widget && native_widget->GetWidget())
-      owned->insert(native_widget->GetWidget());
-    GetAllOwnedWidgets(transient_child, owned);
-  }
-
-  // Add all child windows.
-  for (aura::Window* child : native_view->children())
-    GetAllChildWidgets(child, owned);
-}
-
-// static
-void NativeWidgetPrivate::ReparentNativeView(gfx::NativeView native_view,
-                                             gfx::NativeView new_parent) {
-  DCHECK(native_view != new_parent);
-
-  gfx::NativeView previous_parent = native_view->parent();
-  if (previous_parent == new_parent)
-    return;
-
-  Widget::Widgets widgets;
-  GetAllChildWidgets(native_view, &widgets);
-
-  // First notify all the widgets that they are being disassociated
-  // from their previous parent.
-  for (Widget::Widgets::iterator it = widgets.begin();
-      it != widgets.end(); ++it) {
-    (*it)->NotifyNativeViewHierarchyWillChange();
-  }
-
-  if (new_parent) {
-    new_parent->AddChild(native_view);
-  } else {
-    // The following looks weird, but it's the equivalent of what aura has
-    // always done. (The previous behaviour of aura::Window::SetParent() used
-    // NULL as a special value that meant ask the WindowTreeClient where things
-    // should go.)
-    //
-    // This probably isn't strictly correct, but its an invariant that a Window
-    // in use will be attached to a RootWindow, so we can't just call
-    // RemoveChild here. The only possible thing that could assign a RootWindow
-    // in this case is the stacking client of the current RootWindow. This
-    // matches our previous behaviour; the global stacking client would almost
-    // always reattach the window to the same RootWindow.
-    aura::Window* root_window = native_view->GetRootWindow();
-    aura::client::ParentWindowWithContext(
-        native_view, root_window, root_window->GetBoundsInScreen());
-  }
-
-  // And now, notify them that they have a brand new parent.
-  for (Widget::Widgets::iterator it = widgets.begin();
-      it != widgets.end(); ++it) {
-    (*it)->NotifyNativeViewHierarchyChanged();
-  }
-}
-
-// static
-bool NativeWidgetPrivate::IsMouseButtonDown() {
-  return aura::Env::GetInstance()->IsMouseButtonDown();
-}
-
-// static
-gfx::FontList NativeWidgetPrivate::GetWindowTitleFontList() {
-#if defined(OS_WIN)
-  NONCLIENTMETRICS_XP ncm;
-  base::win::GetNonClientMetrics(&ncm);
-  l10n_util::AdjustUIFont(&(ncm.lfCaptionFont));
-  base::win::ScopedHFONT caption_font(CreateFontIndirect(&(ncm.lfCaptionFont)));
-  return gfx::FontList(gfx::Font(caption_font));
-#else
-  return gfx::FontList();
-#endif
-}
-
-}  // namespace internal
 }  // namespace views