Introduce AndroidFocusRules and NativeWidgetAndroid

ui/views/widget/android/native_widget_android.h

-// 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.
 
-#ifndef UI_VIEWS_WIDGET_NATIVE_WIDGET_AURA_H_
-#define UI_VIEWS_WIDGET_NATIVE_WIDGET_AURA_H_
+#ifndef UI_VIEWS_WIDGET_ANDROID_NATIVE_WIDGET_ANDROID_H_
+#define UI_VIEWS_WIDGET_ANDROID_NATIVE_WIDGET_ANDROID_H_
 
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "ui/aura/client/focus_change_observer.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
+#include "ui/aura/window_tree_host_observer.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/events/event_constants.h"
 #include "ui/views/views_export.h"
 #include "ui/views/widget/native_widget_private.h"
 #include "ui/wm/public/activation_change_observer.h"
 #include "ui/wm/public/activation_delegate.h"
 #include "ui/wm/public/drag_drop_delegate.h"
 
 namespace aura {
 class Window;
+class WindowTreeHost;
+namespace client {
+class DefaultCaptureClient;
+class DispatcherClient;
+class ScreenPositionClient;
+class WindowTreeClient;
+}
 }
 namespace gfx {
 class FontList;
 }
+namespace wm {
+class FocusController;
+}
 
 namespace views {
 
-class DropHelper;
 class TooltipManagerAura;
 class WindowReorderer;
 
-class VIEWS_EXPORT NativeWidgetAura
+// NativeWidgetAndroid creates and hosts the Widget in an Android native window.
+// It is used to create a top level window on Android platform.
+class VIEWS_EXPORT NativeWidgetAndroid
     : public internal::NativeWidgetPrivate,
       public aura::WindowDelegate,
-      public aura::WindowObserver,
       public aura::client::ActivationDelegate,
       public aura::client::ActivationChangeObserver,
       public aura::client::FocusChangeObserver,
-      public aura::client::DragDropDelegate {
+      public aura::client::DragDropDelegate,
+      public aura::WindowTreeHostObserver {
  public:
-  explicit NativeWidgetAura(internal::NativeWidgetDelegate* delegate);
+  explicit NativeWidgetAndroid(internal::NativeWidgetDelegate* delegate);
 
-  // Called internally by NativeWidgetAura and DesktopNativeWidgetAura to
-  // associate |native_widget| with |window|.
-  static void RegisterNativeWidgetForWindow(
-      internal::NativeWidgetPrivate* native_widget,
-      aura::Window* window);
+  aura::WindowTreeHost* host() { return host_.get(); }
 
   // Overridden from internal::NativeWidgetPrivate:
   void InitNativeWidget(const Widget::InitParams& params) override;
   NonClientFrameView* CreateNonClientFrameView() override;
   bool ShouldUseNativeFrame() const override;
   bool ShouldWindowContentsBeTransparent() const override;
   void FrameTypeChanged() override;
   Widget* GetWidget() override;
   const Widget* GetWidget() const override;
   gfx::NativeView GetNativeView() const override;
@@ skipping 87 matching lines @@
   bool CanFocus() override;
   void OnCaptureLost() override;
   void OnPaint(const ui::PaintContext& context) override;
   void OnDeviceScaleFactorChanged(float device_scale_factor) override;
   void OnWindowDestroying(aura::Window* window) override;
   void OnWindowDestroyed(aura::Window* window) override;
   void OnWindowTargetVisibilityChanged(bool visible) override;
   bool HasHitTestMask() const override;
   void GetHitTestMask(gfx::Path* mask) const override;
 
-  // Overridden from aura::WindowObserver:
-  void OnWindowPropertyChanged(aura::Window* window,
-                               const void* key,
-                               intptr_t old) override;
-
   // Overridden from ui::EventHandler:
   void OnKeyEvent(ui::KeyEvent* event) override;
   void OnMouseEvent(ui::MouseEvent* event) override;
   void OnScrollEvent(ui::ScrollEvent* event) override;
   void OnGestureEvent(ui::GestureEvent* event) override;
 
   // Overridden from aura::client::ActivationDelegate:
   bool ShouldActivate() const override;
 
   // Overridden from aura::client::ActivationChangeObserver:
   void OnWindowActivated(
       aura::client::ActivationChangeObserver::ActivationReason reason,
       aura::Window* gained_active,
       aura::Window* lost_active) override;
 
   // Overridden from aura::client::FocusChangeObserver:
   void OnWindowFocused(aura::Window* gained_focus,
                        aura::Window* lost_focus) override;
 
   // Overridden from aura::client::DragDropDelegate:
   void OnDragEntered(const ui::DropTargetEvent& event) override;
   int OnDragUpdated(const ui::DropTargetEvent& event) override;
   void OnDragExited() override;
   int OnPerformDrop(const ui::DropTargetEvent& event) override;
 
+  // Overridden from aura::WindowTreeHostObserver:
+  void OnHostCloseRequested(const aura::WindowTreeHost* host) override;
+  void OnHostResized(const aura::WindowTreeHost* host) override;
+  void OnHostMoved(const aura::WindowTreeHost* host,
+                   const gfx::Point& new_origin) override;
+
  protected:
-  ~NativeWidgetAura() override;
+  ~NativeWidgetAndroid() override;
 
   internal::NativeWidgetDelegate* delegate() { return delegate_; }
 
  private:
   class ActiveWindowObserver;
 
   bool IsDocked() const;
   void SetInitialFocus(ui::WindowShowState show_state);
 
   internal::NativeWidgetDelegate* delegate_;
@@ skipping 13 matching lines @@
 
   // The saved window state for exiting full screen state.
   ui::WindowShowState saved_window_state_;
 
   scoped_ptr<TooltipManagerAura> tooltip_manager_;
 
   // Reorders child windows of |window_| associated with a view based on the
   // order of the associated views in the widget's view hierarchy.
   scoped_ptr<WindowReorderer> window_reorderer_;
 
-  scoped_ptr<DropHelper> drop_helper_;
-  int last_drop_operation_;
+  scoped_ptr<aura::WindowTreeHost> host_;
+  scoped_ptr<wm::FocusController> focus_client_;
+  scoped_ptr<aura::client::DefaultCaptureClient> capture_client_;
+  scoped_ptr<aura::client::WindowTreeClient> window_tree_client_;
+  scoped_ptr<aura::client::ScreenPositionClient> screen_position_client_;
+  scoped_ptr<aura::client::DispatcherClient> dispatcher_client_;
 
-  // The following factory is used for calls to close the NativeWidgetAura
-  // instance.
-  base::WeakPtrFactory<NativeWidgetAura> close_widget_factory_;
+  // The following factory is used for calls to close the
+  // NativeWidgetAndroid instance.
+  base::WeakPtrFactory<NativeWidgetAndroid> close_widget_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(NativeWidgetAura);
+  DISALLOW_COPY_AND_ASSIGN(NativeWidgetAndroid);
 };
 
 }  // namespace views
 
-#endif  // UI_VIEWS_WIDGET_NATIVE_WIDGET_AURA_H_
+#endif  // UI_VIEWS_WIDGET_ANDROID_NATIVE_WIDGET_ANDROID_H_