Home | History | Annotate | Download | only in desktop_aura 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/debug/trace_event.h"
      9 #include "ui/aura/client/aura_constants.h"
     10 #include "ui/aura/client/cursor_client.h"
     11 #include "ui/aura/client/focus_client.h"
     12 #include "ui/aura/client/window_tree_client.h"
     13 #include "ui/aura/window.h"
     14 #include "ui/aura/window_observer.h"
     15 #include "ui/aura/window_property.h"
     16 #include "ui/aura/window_tree_host.h"
     17 #include "ui/base/hit_test.h"
     18 #include "ui/base/ui_base_switches_util.h"
     19 #include "ui/compositor/layer.h"
     20 #include "ui/gfx/canvas.h"
     21 #include "ui/gfx/display.h"
     22 #include "ui/gfx/point_conversions.h"
     23 #include "ui/gfx/geometry/rect.h"
     24 #include "ui/gfx/screen.h"
     25 #include "ui/gfx/size_conversions.h"
     26 #include "ui/native_theme/native_theme.h"
     27 #include "ui/views/corewm/tooltip.h"
     28 #include "ui/views/corewm/tooltip_controller.h"
     29 #include "ui/views/drag_utils.h"
     30 #include "ui/views/ime/input_method_bridge.h"
     31 #include "ui/views/ime/null_input_method.h"
     32 #include "ui/views/view_constants_aura.h"
     33 #include "ui/views/widget/desktop_aura/desktop_capture_client.h"
     34 #include "ui/views/widget/desktop_aura/desktop_cursor_loader_updater.h"
     35 #include "ui/views/widget/desktop_aura/desktop_dispatcher_client.h"
     36 #include "ui/views/widget/desktop_aura/desktop_event_client.h"
     37 #include "ui/views/widget/desktop_aura/desktop_focus_rules.h"
     38 #include "ui/views/widget/desktop_aura/desktop_native_cursor_manager.h"
     39 #include "ui/views/widget/desktop_aura/desktop_screen_position_client.h"
     40 #include "ui/views/widget/desktop_aura/desktop_window_tree_host.h"
     41 #include "ui/views/widget/drop_helper.h"
     42 #include "ui/views/widget/native_widget_aura.h"
     43 #include "ui/views/widget/root_view.h"
     44 #include "ui/views/widget/tooltip_manager_aura.h"
     45 #include "ui/views/widget/widget.h"
     46 #include "ui/views/widget/widget_aura_utils.h"
     47 #include "ui/views/widget/widget_delegate.h"
     48 #include "ui/views/widget/window_reorderer.h"
     49 #include "ui/views/window/native_frame_view.h"
     50 #include "ui/wm/core/compound_event_filter.h"
     51 #include "ui/wm/core/cursor_manager.h"
     52 #include "ui/wm/core/focus_controller.h"
     53 #include "ui/wm/core/input_method_event_filter.h"
     54 #include "ui/wm/core/native_cursor_manager.h"
     55 #include "ui/wm/core/shadow_controller.h"
     56 #include "ui/wm/core/shadow_types.h"
     57 #include "ui/wm/core/visibility_controller.h"
     58 #include "ui/wm/core/window_modality_controller.h"
     59 #include "ui/wm/public/activation_client.h"
     60 #include "ui/wm/public/drag_drop_client.h"
     61 
     62 #if defined(OS_WIN)
     63 #include "ui/base/win/shell.h"
     64 #include "ui/gfx/win/dpi.h"
     65 #endif
     66 
     67 DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(VIEWS_EXPORT,
     68                                       views::DesktopNativeWidgetAura*);
     69 
     70 namespace views {
     71 
     72 DEFINE_WINDOW_PROPERTY_KEY(DesktopNativeWidgetAura*,
     73                            kDesktopNativeWidgetAuraKey, NULL);
     74 
     75 namespace {
     76 
     77 // This class provides functionality to create a top level widget to host a
     78 // child window.
     79 class DesktopNativeWidgetTopLevelHandler : public aura::WindowObserver {
     80  public:
     81   // This function creates a widget with the bounds passed in which eventually
     82   // becomes the parent of the child window passed in.
     83   static aura::Window* CreateParentWindow(aura::Window* child_window,
     84                                           const gfx::Rect& bounds,
     85                                           bool full_screen,
     86                                           bool root_is_always_on_top) {
     87     // This instance will get deleted when the widget is destroyed.
     88     DesktopNativeWidgetTopLevelHandler* top_level_handler =
     89         new DesktopNativeWidgetTopLevelHandler;
     90 
     91     child_window->SetBounds(gfx::Rect(bounds.size()));
     92 
     93     Widget::InitParams init_params;
     94     init_params.type = full_screen ? Widget::InitParams::TYPE_WINDOW :
     95         Widget::InitParams::TYPE_POPUP;
     96     init_params.bounds = bounds;
     97     init_params.ownership = Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET;
     98     init_params.layer_type = aura::WINDOW_LAYER_NOT_DRAWN;
     99     init_params.activatable = full_screen ?
    100         Widget::InitParams::ACTIVATABLE_YES :
    101         Widget::InitParams::ACTIVATABLE_NO;
    102     init_params.keep_on_top = root_is_always_on_top;
    103 
    104     // This widget instance will get deleted when the window is
    105     // destroyed.
    106     top_level_handler->top_level_widget_ = new Widget();
    107     top_level_handler->top_level_widget_->Init(init_params);
    108 
    109     top_level_handler->top_level_widget_->SetFullscreen(full_screen);
    110     top_level_handler->top_level_widget_->Show();
    111 
    112     aura::Window* native_window =
    113         top_level_handler->top_level_widget_->GetNativeView();
    114     child_window->AddObserver(top_level_handler);
    115     native_window->AddObserver(top_level_handler);
    116     top_level_handler->child_window_ = child_window;
    117     return native_window;
    118   }
    119 
    120   // aura::WindowObserver overrides
    121   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
    122     window->RemoveObserver(this);
    123 
    124     // If the widget is being destroyed by the OS then we should not try and
    125     // destroy it again.
    126     if (top_level_widget_ &&
    127         window == top_level_widget_->GetNativeView()) {
    128       top_level_widget_ = NULL;
    129       return;
    130     }
    131 
    132     if (top_level_widget_) {
    133       DCHECK(top_level_widget_->GetNativeView());
    134       top_level_widget_->GetNativeView()->RemoveObserver(this);
    135       // When we receive a notification that the child of the window created
    136       // above is being destroyed we go ahead and initiate the destruction of
    137       // the corresponding widget.
    138       top_level_widget_->Close();
    139       top_level_widget_ = NULL;
    140     }
    141     delete this;
    142   }
    143 
    144   virtual void OnWindowBoundsChanged(aura::Window* window,
    145                                      const gfx::Rect& old_bounds,
    146                                      const gfx::Rect& new_bounds) OVERRIDE {
    147     if (top_level_widget_ && window == child_window_)
    148       top_level_widget_->SetSize(new_bounds.size());
    149   }
    150 
    151  private:
    152   DesktopNativeWidgetTopLevelHandler()
    153       : top_level_widget_(NULL),
    154         child_window_(NULL) {}
    155 
    156   virtual ~DesktopNativeWidgetTopLevelHandler() {}
    157 
    158   Widget* top_level_widget_;
    159   aura::Window* child_window_;
    160 
    161   DISALLOW_COPY_AND_ASSIGN(DesktopNativeWidgetTopLevelHandler);
    162 };
    163 
    164 class DesktopNativeWidgetAuraWindowTreeClient :
    165     public aura::client::WindowTreeClient {
    166  public:
    167   explicit DesktopNativeWidgetAuraWindowTreeClient(
    168       aura::Window* root_window)
    169       : root_window_(root_window) {
    170     aura::client::SetWindowTreeClient(root_window_, this);
    171   }
    172   virtual ~DesktopNativeWidgetAuraWindowTreeClient() {
    173     aura::client::SetWindowTreeClient(root_window_, NULL);
    174   }
    175 
    176   // Overridden from client::WindowTreeClient:
    177   virtual aura::Window* GetDefaultParent(aura::Window* context,
    178                                          aura::Window* window,
    179                                          const gfx::Rect& bounds) OVERRIDE {
    180     bool is_fullscreen = window->GetProperty(aura::client::kShowStateKey) ==
    181         ui::SHOW_STATE_FULLSCREEN;
    182     bool is_menu = window->type() == ui::wm::WINDOW_TYPE_MENU;
    183 
    184     if (is_fullscreen || is_menu) {
    185       bool root_is_always_on_top = false;
    186       internal::NativeWidgetPrivate* native_widget =
    187           DesktopNativeWidgetAura::ForWindow(root_window_);
    188       if (native_widget)
    189         root_is_always_on_top = native_widget->IsAlwaysOnTop();
    190 
    191       return DesktopNativeWidgetTopLevelHandler::CreateParentWindow(
    192           window, bounds, is_fullscreen, root_is_always_on_top);
    193     }
    194     return root_window_;
    195   }
    196 
    197  private:
    198   aura::Window* root_window_;
    199 
    200   DISALLOW_COPY_AND_ASSIGN(DesktopNativeWidgetAuraWindowTreeClient);
    201 };
    202 
    203 }  // namespace
    204 
    205 class FocusManagerEventHandler : public ui::EventHandler {
    206  public:
    207   FocusManagerEventHandler(DesktopNativeWidgetAura* desktop_native_widget_aura)
    208       : desktop_native_widget_aura_(desktop_native_widget_aura) {}
    209 
    210   // Implementation of ui::EventHandler:
    211   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
    212     Widget* widget = desktop_native_widget_aura_->GetWidget();
    213     if (widget && widget->GetFocusManager()->GetFocusedView() &&
    214         !widget->GetFocusManager()->OnKeyEvent(*event)) {
    215       event->SetHandled();
    216     }
    217   }
    218 
    219  private:
    220   DesktopNativeWidgetAura* desktop_native_widget_aura_;
    221 
    222   DISALLOW_COPY_AND_ASSIGN(FocusManagerEventHandler);
    223 };
    224 
    225 class RootWindowDestructionObserver : public aura::WindowObserver {
    226  public:
    227   explicit RootWindowDestructionObserver(DesktopNativeWidgetAura* parent)
    228     : parent_(parent) {}
    229   virtual ~RootWindowDestructionObserver() {}
    230 
    231  private:
    232   // Overridden from aura::WindowObserver:
    233   virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE {
    234     parent_->RootWindowDestroyed();
    235     window->RemoveObserver(this);
    236     delete this;
    237   }
    238 
    239   DesktopNativeWidgetAura* parent_;
    240 
    241   DISALLOW_COPY_AND_ASSIGN(RootWindowDestructionObserver);
    242 };
    243 
    244 ////////////////////////////////////////////////////////////////////////////////
    245 // DesktopNativeWidgetAura, public:
    246 
    247 int DesktopNativeWidgetAura::cursor_reference_count_ = 0;
    248 DesktopNativeCursorManager* DesktopNativeWidgetAura::native_cursor_manager_ =
    249     NULL;
    250 wm::CursorManager* DesktopNativeWidgetAura::cursor_manager_ = NULL;
    251 
    252 DesktopNativeWidgetAura::DesktopNativeWidgetAura(
    253     internal::NativeWidgetDelegate* delegate)
    254     : desktop_window_tree_host_(NULL),
    255       ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET),
    256       close_widget_factory_(this),
    257       content_window_container_(NULL),
    258       content_window_(new aura::Window(this)),
    259       native_widget_delegate_(delegate),
    260       last_drop_operation_(ui::DragDropTypes::DRAG_NONE),
    261       restore_focus_on_activate_(false),
    262       cursor_(gfx::kNullCursor),
    263       widget_type_(Widget::InitParams::TYPE_WINDOW) {
    264   aura::client::SetFocusChangeObserver(content_window_, this);
    265   aura::client::SetActivationChangeObserver(content_window_, this);
    266 }
    267 
    268 DesktopNativeWidgetAura::~DesktopNativeWidgetAura() {
    269   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
    270     delete native_widget_delegate_;
    271   else
    272     CloseNow();
    273 }
    274 
    275 // static
    276 DesktopNativeWidgetAura* DesktopNativeWidgetAura::ForWindow(
    277     aura::Window* window) {
    278   return window->GetProperty(kDesktopNativeWidgetAuraKey);
    279 }
    280 
    281 void DesktopNativeWidgetAura::OnHostClosed() {
    282   // Don't invoke Widget::OnNativeWidgetDestroying(), its done by
    283   // DesktopWindowTreeHost.
    284 
    285   // The WindowModalityController is at the front of the event pretarget
    286   // handler list. We destroy it first to preserve order symantics.
    287   if (window_modality_controller_)
    288     window_modality_controller_.reset();
    289 
    290   // Make sure we don't have capture. Otherwise CaptureController and
    291   // WindowEventDispatcher are left referencing a deleted Window.
    292   {
    293     aura::Window* capture_window = capture_client_->GetCaptureWindow();
    294     if (capture_window && host_->window()->Contains(capture_window))
    295       capture_window->ReleaseCapture();
    296   }
    297 
    298   // DesktopWindowTreeHost owns the ActivationController which ShadowController
    299   // references. Make sure we destroy ShadowController early on.
    300   shadow_controller_.reset();
    301   tooltip_manager_.reset();
    302   if (tooltip_controller_.get()) {
    303     host_->window()->RemovePreTargetHandler(tooltip_controller_.get());
    304     aura::client::SetTooltipClient(host_->window(), NULL);
    305     tooltip_controller_.reset();
    306   }
    307 
    308   root_window_event_filter_->RemoveHandler(input_method_event_filter_.get());
    309 
    310   window_tree_client_.reset();  // Uses host_->dispatcher() at destruction.
    311 
    312   capture_client_.reset();  // Uses host_->dispatcher() at destruction.
    313 
    314   // FocusController uses |content_window_|. Destroy it now so that we don't
    315   // have to worry about the possibility of FocusController attempting to use
    316   // |content_window_| after it's been destroyed but before all child windows
    317   // have been destroyed.
    318   host_->window()->RemovePreTargetHandler(focus_client_.get());
    319   aura::client::SetFocusClient(host_->window(), NULL);
    320   aura::client::SetActivationClient(host_->window(), NULL);
    321   focus_client_.reset();
    322 
    323   host_->RemoveObserver(this);
    324   host_.reset();  // Uses input_method_event_filter_ at destruction.
    325   // WindowEventDispatcher owns |desktop_window_tree_host_|.
    326   desktop_window_tree_host_ = NULL;
    327   content_window_ = NULL;
    328 
    329   native_widget_delegate_->OnNativeWidgetDestroyed();
    330   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
    331     delete this;
    332 }
    333 
    334 void DesktopNativeWidgetAura::OnDesktopWindowTreeHostDestroyed(
    335     aura::WindowTreeHost* host) {
    336   // |dispatcher_| is still valid, but DesktopWindowTreeHost is nearly
    337   // destroyed. Do cleanup here of members DesktopWindowTreeHost may also use.
    338   aura::client::SetDispatcherClient(host->window(), NULL);
    339   dispatcher_client_.reset();
    340 
    341   // We explicitly do NOT clear the cursor client property. Since the cursor
    342   // manager is a singleton, it can outlive any window hierarchy, and it's
    343   // important that objects attached to this destroying window hierarchy have
    344   // an opportunity to deregister their observers from the cursor manager.
    345   // They may want to do this when they are notified that they're being
    346   // removed from the window hierarchy, which happens soon after this
    347   // function when DesktopWindowTreeHost* calls DestroyDispatcher().
    348   native_cursor_manager_->RemoveHost(host);
    349 
    350   aura::client::SetScreenPositionClient(host->window(), NULL);
    351   position_client_.reset();
    352 
    353   aura::client::SetDragDropClient(host->window(), NULL);
    354   drag_drop_client_.reset();
    355 
    356   aura::client::SetEventClient(host->window(), NULL);
    357   event_client_.reset();
    358 }
    359 
    360 void DesktopNativeWidgetAura::HandleActivationChanged(bool active) {
    361   native_widget_delegate_->OnNativeWidgetActivationChanged(active);
    362   aura::client::ActivationClient* activation_client =
    363       aura::client::GetActivationClient(host_->window());
    364   if (!activation_client)
    365     return;
    366   if (active) {
    367     if (GetWidget()->HasFocusManager()) {
    368       // This function can be called before the focus manager has had a
    369       // chance to set the focused view. In which case we should get the
    370       // last focused view.
    371       View* view_for_activation =
    372           GetWidget()->GetFocusManager()->GetFocusedView() ?
    373               GetWidget()->GetFocusManager()->GetFocusedView() :
    374                   GetWidget()->GetFocusManager()->GetStoredFocusView();
    375       if (!view_for_activation)
    376         view_for_activation = GetWidget()->GetRootView();
    377       activation_client->ActivateWindow(
    378           view_for_activation->GetWidget()->GetNativeView());
    379     }
    380   } else {
    381     // If we're not active we need to deactivate the corresponding
    382     // aura::Window. This way if a child widget is active it gets correctly
    383     // deactivated (child widgets don't get native desktop activation changes,
    384     // only aura activation changes).
    385     aura::Window* active_window = activation_client->GetActiveWindow();
    386     if (active_window)
    387       activation_client->DeactivateWindow(active_window);
    388   }
    389 }
    390 
    391 ////////////////////////////////////////////////////////////////////////////////
    392 // DesktopNativeWidgetAura, internal::NativeWidgetPrivate implementation:
    393 
    394 void DesktopNativeWidgetAura::InitNativeWidget(
    395     const Widget::InitParams& params) {
    396   ownership_ = params.ownership;
    397   widget_type_ = params.type;
    398 
    399   NativeWidgetAura::RegisterNativeWidgetForWindow(this, content_window_);
    400   // Animations on TYPE_WINDOW are handled by the OS. Additionally if we animate
    401   // these windows the size of the window gets augmented, effecting restore
    402   // bounds and maximized windows in bad ways.
    403   if (params.type == Widget::InitParams::TYPE_WINDOW &&
    404       !params.remove_standard_frame) {
    405     content_window_->SetProperty(aura::client::kAnimationsDisabledKey, true);
    406   }
    407   content_window_->SetType(GetAuraWindowTypeForWidgetType(params.type));
    408   content_window_->Init(params.layer_type);
    409   wm::SetShadowType(content_window_, wm::SHADOW_TYPE_NONE);
    410 
    411   content_window_container_ = new aura::Window(NULL);
    412   content_window_container_->Init(aura::WINDOW_LAYER_NOT_DRAWN);
    413   content_window_container_->Show();
    414   content_window_container_->AddChild(content_window_);
    415 
    416   desktop_window_tree_host_ = params.desktop_window_tree_host ?
    417       params.desktop_window_tree_host :
    418       DesktopWindowTreeHost::Create(native_widget_delegate_, this);
    419   host_.reset(desktop_window_tree_host_->AsWindowTreeHost());
    420   desktop_window_tree_host_->Init(content_window_, params);
    421 
    422   // Mark this window as Desktop root window.
    423   host_->window()->SetProperty(views::kDesktopRootWindow, true);
    424 
    425   host_->InitHost();
    426   host_->window()->AddChild(content_window_container_);
    427   host_->window()->SetProperty(kDesktopNativeWidgetAuraKey, this);
    428 
    429   host_->window()->AddObserver(new RootWindowDestructionObserver(this));
    430 
    431   // The WindowsModalityController event filter should be at the head of the
    432   // pre target handlers list. This ensures that it handles input events first
    433   // when modal windows are at the top of the Zorder.
    434   if (widget_type_ == Widget::InitParams::TYPE_WINDOW)
    435     window_modality_controller_.reset(
    436         new wm::WindowModalityController(host_->window()));
    437 
    438   // |root_window_event_filter_| must be created before
    439   // OnWindowTreeHostCreated() is invoked.
    440 
    441   // CEF sets focus to the window the user clicks down on.
    442   // TODO(beng): see if we can't do this some other way. CEF seems a heavy-
    443   //             handed way of accomplishing focus.
    444   // No event filter for aura::Env. Create CompoundEventFilter per
    445   // WindowEventDispatcher.
    446   root_window_event_filter_.reset(new wm::CompoundEventFilter);
    447   host_->window()->AddPreTargetHandler(root_window_event_filter_.get());
    448 
    449   // The host's dispatcher must be added to |native_cursor_manager_| before
    450   // OnNativeWidgetCreated() is called.
    451   cursor_reference_count_++;
    452   if (!native_cursor_manager_) {
    453     native_cursor_manager_ = new DesktopNativeCursorManager(
    454         DesktopCursorLoaderUpdater::Create());
    455   }
    456   if (!cursor_manager_) {
    457     cursor_manager_ = new wm::CursorManager(
    458         scoped_ptr<wm::NativeCursorManager>(native_cursor_manager_));
    459   }
    460   native_cursor_manager_->AddHost(host());
    461   aura::client::SetCursorClient(host_->window(), cursor_manager_);
    462 
    463   desktop_window_tree_host_->OnNativeWidgetCreated(params);
    464 
    465   UpdateWindowTransparency();
    466 
    467   capture_client_.reset(new DesktopCaptureClient(host_->window()));
    468 
    469   wm::FocusController* focus_controller =
    470       new wm::FocusController(new DesktopFocusRules(content_window_));
    471   focus_client_.reset(focus_controller);
    472   aura::client::SetFocusClient(host_->window(), focus_controller);
    473   aura::client::SetActivationClient(host_->window(), focus_controller);
    474   host_->window()->AddPreTargetHandler(focus_controller);
    475 
    476   dispatcher_client_.reset(new DesktopDispatcherClient);
    477   aura::client::SetDispatcherClient(host_->window(),
    478                                     dispatcher_client_.get());
    479 
    480   position_client_.reset(new DesktopScreenPositionClient(host_->window()));
    481 
    482   InstallInputMethodEventFilter();
    483 
    484   drag_drop_client_ = desktop_window_tree_host_->CreateDragDropClient(
    485       native_cursor_manager_);
    486   aura::client::SetDragDropClient(host_->window(),
    487                                   drag_drop_client_.get());
    488 
    489   static_cast<aura::client::FocusClient*>(focus_client_.get())->
    490       FocusWindow(content_window_);
    491 
    492   OnHostResized(host());
    493 
    494   host_->AddObserver(this);
    495 
    496   window_tree_client_.reset(
    497       new DesktopNativeWidgetAuraWindowTreeClient(host_->window()));
    498   drop_helper_.reset(new DropHelper(GetWidget()->GetRootView()));
    499   aura::client::SetDragDropDelegate(content_window_, this);
    500 
    501   if (params.type != Widget::InitParams::TYPE_TOOLTIP) {
    502     tooltip_manager_.reset(new TooltipManagerAura(GetWidget()));
    503     tooltip_controller_.reset(
    504         new corewm::TooltipController(
    505             desktop_window_tree_host_->CreateTooltip()));
    506     aura::client::SetTooltipClient(host_->window(),
    507                                    tooltip_controller_.get());
    508     host_->window()->AddPreTargetHandler(tooltip_controller_.get());
    509   }
    510 
    511   if (params.opacity == Widget::InitParams::TRANSLUCENT_WINDOW) {
    512     visibility_controller_.reset(new wm::VisibilityController);
    513     aura::client::SetVisibilityClient(host_->window(),
    514                                       visibility_controller_.get());
    515     wm::SetChildWindowVisibilityChangesAnimated(host_->window());
    516     wm::SetChildWindowVisibilityChangesAnimated(
    517         content_window_container_);
    518   }
    519 
    520   if (params.type == Widget::InitParams::TYPE_WINDOW) {
    521     focus_manager_event_handler_.reset(new FocusManagerEventHandler(this));
    522     host_->window()->AddPreTargetHandler(focus_manager_event_handler_.get());
    523   }
    524 
    525   event_client_.reset(new DesktopEventClient);
    526   aura::client::SetEventClient(host_->window(), event_client_.get());
    527 
    528   aura::client::GetFocusClient(content_window_)->FocusWindow(content_window_);
    529 
    530   aura::client::SetActivationDelegate(content_window_, this);
    531 
    532   shadow_controller_.reset(new wm::ShadowController(
    533       aura::client::GetActivationClient(host_->window())));
    534 
    535   content_window_->SetProperty(aura::client::kCanMaximizeKey,
    536                                GetWidget()->widget_delegate()->CanMaximize());
    537   content_window_->SetProperty(aura::client::kCanResizeKey,
    538                                GetWidget()->widget_delegate()->CanResize());
    539 
    540   window_reorderer_.reset(new WindowReorderer(content_window_,
    541       GetWidget()->GetRootView()));
    542 }
    543 
    544 NonClientFrameView* DesktopNativeWidgetAura::CreateNonClientFrameView() {
    545   return ShouldUseNativeFrame() ? new NativeFrameView(GetWidget()) : NULL;
    546 }
    547 
    548 bool DesktopNativeWidgetAura::ShouldUseNativeFrame() const {
    549   return desktop_window_tree_host_->ShouldUseNativeFrame();
    550 }
    551 
    552 bool DesktopNativeWidgetAura::ShouldWindowContentsBeTransparent() const {
    553   return desktop_window_tree_host_->ShouldWindowContentsBeTransparent();
    554 }
    555 
    556 void DesktopNativeWidgetAura::FrameTypeChanged() {
    557   desktop_window_tree_host_->FrameTypeChanged();
    558   UpdateWindowTransparency();
    559 }
    560 
    561 Widget* DesktopNativeWidgetAura::GetWidget() {
    562   return native_widget_delegate_->AsWidget();
    563 }
    564 
    565 const Widget* DesktopNativeWidgetAura::GetWidget() const {
    566   return native_widget_delegate_->AsWidget();
    567 }
    568 
    569 gfx::NativeView DesktopNativeWidgetAura::GetNativeView() const {
    570   return content_window_;
    571 }
    572 
    573 gfx::NativeWindow DesktopNativeWidgetAura::GetNativeWindow() const {
    574   return content_window_;
    575 }
    576 
    577 Widget* DesktopNativeWidgetAura::GetTopLevelWidget() {
    578   return GetWidget();
    579 }
    580 
    581 const ui::Compositor* DesktopNativeWidgetAura::GetCompositor() const {
    582   return content_window_ ? content_window_->layer()->GetCompositor() : NULL;
    583 }
    584 
    585 ui::Compositor* DesktopNativeWidgetAura::GetCompositor() {
    586   return const_cast<ui::Compositor*>(
    587       const_cast<const DesktopNativeWidgetAura*>(this)->GetCompositor());
    588 }
    589 
    590 ui::Layer* DesktopNativeWidgetAura::GetLayer() {
    591   return content_window_ ? content_window_->layer() : NULL;
    592 }
    593 
    594 void DesktopNativeWidgetAura::ReorderNativeViews() {
    595   window_reorderer_->ReorderChildWindows();
    596 }
    597 
    598 void DesktopNativeWidgetAura::ViewRemoved(View* view) {
    599   DCHECK(drop_helper_.get() != NULL);
    600   drop_helper_->ResetTargetViewIfEquals(view);
    601 }
    602 
    603 void DesktopNativeWidgetAura::SetNativeWindowProperty(const char* name,
    604                                                       void* value) {
    605   if (content_window_)
    606     content_window_->SetNativeWindowProperty(name, value);
    607 }
    608 
    609 void* DesktopNativeWidgetAura::GetNativeWindowProperty(const char* name) const {
    610   return content_window_ ?
    611       content_window_->GetNativeWindowProperty(name) : NULL;
    612 }
    613 
    614 TooltipManager* DesktopNativeWidgetAura::GetTooltipManager() const {
    615   return tooltip_manager_.get();
    616 }
    617 
    618 void DesktopNativeWidgetAura::SetCapture() {
    619   if (!content_window_)
    620     return;
    621 
    622   content_window_->SetCapture();
    623 }
    624 
    625 void DesktopNativeWidgetAura::ReleaseCapture() {
    626   if (!content_window_)
    627     return;
    628 
    629   content_window_->ReleaseCapture();
    630 }
    631 
    632 bool DesktopNativeWidgetAura::HasCapture() const {
    633   return content_window_ && content_window_->HasCapture() &&
    634       desktop_window_tree_host_->HasCapture();
    635 }
    636 
    637 InputMethod* DesktopNativeWidgetAura::CreateInputMethod() {
    638   if (switches::IsTextInputFocusManagerEnabled())
    639     return new NullInputMethod();
    640 
    641   ui::InputMethod* host = input_method_event_filter_->input_method();
    642   return new InputMethodBridge(this, host, false);
    643 }
    644 
    645 internal::InputMethodDelegate*
    646     DesktopNativeWidgetAura::GetInputMethodDelegate() {
    647   return this;
    648 }
    649 
    650 ui::InputMethod* DesktopNativeWidgetAura::GetHostInputMethod() {
    651   return input_method_event_filter_->input_method();
    652 }
    653 
    654 void DesktopNativeWidgetAura::CenterWindow(const gfx::Size& size) {
    655   if (content_window_)
    656     desktop_window_tree_host_->CenterWindow(size);
    657 }
    658 
    659 void DesktopNativeWidgetAura::GetWindowPlacement(
    660       gfx::Rect* bounds,
    661       ui::WindowShowState* maximized) const {
    662   if (content_window_)
    663     desktop_window_tree_host_->GetWindowPlacement(bounds, maximized);
    664 }
    665 
    666 bool DesktopNativeWidgetAura::SetWindowTitle(const base::string16& title) {
    667   if (!content_window_)
    668     return false;
    669   return desktop_window_tree_host_->SetWindowTitle(title);
    670 }
    671 
    672 void DesktopNativeWidgetAura::SetWindowIcons(const gfx::ImageSkia& window_icon,
    673                                              const gfx::ImageSkia& app_icon) {
    674   if (content_window_)
    675     desktop_window_tree_host_->SetWindowIcons(window_icon, app_icon);
    676 }
    677 
    678 void DesktopNativeWidgetAura::InitModalType(ui::ModalType modal_type) {
    679   // 99% of the time, we should not be asked to create a
    680   // DesktopNativeWidgetAura that is modal. We only support window modal
    681   // dialogs on the same lines as non AURA.
    682   desktop_window_tree_host_->InitModalType(modal_type);
    683 }
    684 
    685 gfx::Rect DesktopNativeWidgetAura::GetWindowBoundsInScreen() const {
    686   return content_window_ ?
    687       desktop_window_tree_host_->GetWindowBoundsInScreen() : gfx::Rect();
    688 }
    689 
    690 gfx::Rect DesktopNativeWidgetAura::GetClientAreaBoundsInScreen() const {
    691   return content_window_ ?
    692       desktop_window_tree_host_->GetClientAreaBoundsInScreen() : gfx::Rect();
    693 }
    694 
    695 gfx::Rect DesktopNativeWidgetAura::GetRestoredBounds() const {
    696   return content_window_ ?
    697       desktop_window_tree_host_->GetRestoredBounds() : gfx::Rect();
    698 }
    699 
    700 void DesktopNativeWidgetAura::SetBounds(const gfx::Rect& bounds) {
    701   if (!content_window_)
    702     return;
    703   // TODO(ananta)
    704   // This code by default scales the bounds rectangle by 1.
    705   // We could probably get rid of this and similar logic from
    706   // the DesktopNativeWidgetAura::OnWindowTreeHostResized function.
    707   float scale = 1;
    708   aura::Window* root = host_->window();
    709   if (root) {
    710     scale = gfx::Screen::GetScreenFor(root)->
    711         GetDisplayNearestWindow(root).device_scale_factor();
    712   }
    713   gfx::Rect bounds_in_pixels =
    714     gfx::ScaleToEnclosingRect(bounds, scale, scale);
    715   desktop_window_tree_host_->AsWindowTreeHost()->SetBounds(bounds_in_pixels);
    716 }
    717 
    718 void DesktopNativeWidgetAura::SetSize(const gfx::Size& size) {
    719   if (content_window_)
    720     desktop_window_tree_host_->SetSize(size);
    721 }
    722 
    723 void DesktopNativeWidgetAura::StackAbove(gfx::NativeView native_view) {
    724 }
    725 
    726 void DesktopNativeWidgetAura::StackAtTop() {
    727   if (content_window_)
    728     desktop_window_tree_host_->StackAtTop();
    729 }
    730 
    731 void DesktopNativeWidgetAura::StackBelow(gfx::NativeView native_view) {
    732 }
    733 
    734 void DesktopNativeWidgetAura::SetShape(gfx::NativeRegion shape) {
    735   if (content_window_)
    736     desktop_window_tree_host_->SetShape(shape);
    737 }
    738 
    739 void DesktopNativeWidgetAura::Close() {
    740   if (!content_window_)
    741     return;
    742 
    743   content_window_->SuppressPaint();
    744   content_window_->Hide();
    745 
    746   desktop_window_tree_host_->Close();
    747 }
    748 
    749 void DesktopNativeWidgetAura::CloseNow() {
    750   if (content_window_)
    751     desktop_window_tree_host_->CloseNow();
    752 }
    753 
    754 void DesktopNativeWidgetAura::Show() {
    755   if (!content_window_)
    756     return;
    757   desktop_window_tree_host_->AsWindowTreeHost()->Show();
    758   content_window_->Show();
    759 }
    760 
    761 void DesktopNativeWidgetAura::Hide() {
    762   if (!content_window_)
    763     return;
    764   desktop_window_tree_host_->AsWindowTreeHost()->Hide();
    765   content_window_->Hide();
    766 }
    767 
    768 void DesktopNativeWidgetAura::ShowMaximizedWithBounds(
    769       const gfx::Rect& restored_bounds) {
    770   if (!content_window_)
    771     return;
    772   desktop_window_tree_host_->ShowMaximizedWithBounds(restored_bounds);
    773   content_window_->Show();
    774 }
    775 
    776 void DesktopNativeWidgetAura::ShowWithWindowState(ui::WindowShowState state) {
    777   if (!content_window_)
    778     return;
    779   desktop_window_tree_host_->ShowWindowWithState(state);
    780   content_window_->Show();
    781 }
    782 
    783 bool DesktopNativeWidgetAura::IsVisible() const {
    784   return content_window_ && desktop_window_tree_host_->IsVisible();
    785 }
    786 
    787 void DesktopNativeWidgetAura::Activate() {
    788   if (content_window_)
    789     desktop_window_tree_host_->Activate();
    790 }
    791 
    792 void DesktopNativeWidgetAura::Deactivate() {
    793   if (content_window_)
    794     desktop_window_tree_host_->Deactivate();
    795 }
    796 
    797 bool DesktopNativeWidgetAura::IsActive() const {
    798   return content_window_ && desktop_window_tree_host_->IsActive();
    799 }
    800 
    801 void DesktopNativeWidgetAura::SetAlwaysOnTop(bool always_on_top) {
    802   if (content_window_)
    803     desktop_window_tree_host_->SetAlwaysOnTop(always_on_top);
    804 }
    805 
    806 bool DesktopNativeWidgetAura::IsAlwaysOnTop() const {
    807   return content_window_ && desktop_window_tree_host_->IsAlwaysOnTop();
    808 }
    809 
    810 void DesktopNativeWidgetAura::SetVisibleOnAllWorkspaces(bool always_visible) {
    811   if (content_window_)
    812     desktop_window_tree_host_->SetVisibleOnAllWorkspaces(always_visible);
    813 }
    814 
    815 void DesktopNativeWidgetAura::Maximize() {
    816   if (content_window_)
    817     desktop_window_tree_host_->Maximize();
    818 }
    819 
    820 void DesktopNativeWidgetAura::Minimize() {
    821   if (content_window_)
    822     desktop_window_tree_host_->Minimize();
    823 }
    824 
    825 bool DesktopNativeWidgetAura::IsMaximized() const {
    826   return content_window_ && desktop_window_tree_host_->IsMaximized();
    827 }
    828 
    829 bool DesktopNativeWidgetAura::IsMinimized() const {
    830   return content_window_ && desktop_window_tree_host_->IsMinimized();
    831 }
    832 
    833 void DesktopNativeWidgetAura::Restore() {
    834   if (content_window_)
    835     desktop_window_tree_host_->Restore();
    836 }
    837 
    838 void DesktopNativeWidgetAura::SetFullscreen(bool fullscreen) {
    839   if (content_window_)
    840     desktop_window_tree_host_->SetFullscreen(fullscreen);
    841 }
    842 
    843 bool DesktopNativeWidgetAura::IsFullscreen() const {
    844   return content_window_ && desktop_window_tree_host_->IsFullscreen();
    845 }
    846 
    847 void DesktopNativeWidgetAura::SetOpacity(unsigned char opacity) {
    848   if (content_window_)
    849     desktop_window_tree_host_->SetOpacity(opacity);
    850 }
    851 
    852 void DesktopNativeWidgetAura::SetUseDragFrame(bool use_drag_frame) {
    853 }
    854 
    855 void DesktopNativeWidgetAura::FlashFrame(bool flash_frame) {
    856   if (content_window_)
    857     desktop_window_tree_host_->FlashFrame(flash_frame);
    858 }
    859 
    860 void DesktopNativeWidgetAura::RunShellDrag(
    861     View* view,
    862     const ui::OSExchangeData& data,
    863     const gfx::Point& location,
    864     int operation,
    865     ui::DragDropTypes::DragEventSource source) {
    866   views::RunShellDrag(content_window_, data, location, operation, source);
    867 }
    868 
    869 void DesktopNativeWidgetAura::SchedulePaintInRect(const gfx::Rect& rect) {
    870   if (content_window_)
    871     content_window_->SchedulePaintInRect(rect);
    872 }
    873 
    874 void DesktopNativeWidgetAura::SetCursor(gfx::NativeCursor cursor) {
    875   cursor_ = cursor;
    876   aura::client::CursorClient* cursor_client =
    877       aura::client::GetCursorClient(host_->window());
    878   if (cursor_client)
    879     cursor_client->SetCursor(cursor);
    880 }
    881 
    882 bool DesktopNativeWidgetAura::IsMouseEventsEnabled() const {
    883   if (!content_window_)
    884     return false;
    885   aura::client::CursorClient* cursor_client =
    886       aura::client::GetCursorClient(host_->window());
    887   return cursor_client ? cursor_client->IsMouseEventsEnabled() : true;
    888 }
    889 
    890 void DesktopNativeWidgetAura::ClearNativeFocus() {
    891   desktop_window_tree_host_->ClearNativeFocus();
    892 
    893   if (ShouldActivate()) {
    894     aura::client::GetFocusClient(content_window_)->
    895         ResetFocusWithinActiveWindow(content_window_);
    896   }
    897 }
    898 
    899 gfx::Rect DesktopNativeWidgetAura::GetWorkAreaBoundsInScreen() const {
    900   return desktop_window_tree_host_ ?
    901       desktop_window_tree_host_->GetWorkAreaBoundsInScreen() : gfx::Rect();
    902 }
    903 
    904 Widget::MoveLoopResult DesktopNativeWidgetAura::RunMoveLoop(
    905     const gfx::Vector2d& drag_offset,
    906     Widget::MoveLoopSource source,
    907     Widget::MoveLoopEscapeBehavior escape_behavior) {
    908   if (!content_window_)
    909     return Widget::MOVE_LOOP_CANCELED;
    910   return desktop_window_tree_host_->RunMoveLoop(drag_offset, source,
    911                                                 escape_behavior);
    912 }
    913 
    914 void DesktopNativeWidgetAura::EndMoveLoop() {
    915   if (content_window_)
    916     desktop_window_tree_host_->EndMoveLoop();
    917 }
    918 
    919 void DesktopNativeWidgetAura::SetVisibilityChangedAnimationsEnabled(
    920     bool value) {
    921   if (content_window_)
    922     desktop_window_tree_host_->SetVisibilityChangedAnimationsEnabled(value);
    923 }
    924 
    925 ui::NativeTheme* DesktopNativeWidgetAura::GetNativeTheme() const {
    926   return DesktopWindowTreeHost::GetNativeTheme(content_window_);
    927 }
    928 
    929 void DesktopNativeWidgetAura::OnRootViewLayout() const {
    930   if (content_window_)
    931     desktop_window_tree_host_->OnRootViewLayout();
    932 }
    933 
    934 bool DesktopNativeWidgetAura::IsTranslucentWindowOpacitySupported() const {
    935   return content_window_ &&
    936       desktop_window_tree_host_->IsTranslucentWindowOpacitySupported();
    937 }
    938 
    939 void DesktopNativeWidgetAura::RepostNativeEvent(gfx::NativeEvent native_event) {
    940   OnEvent(native_event);
    941 }
    942 
    943 ////////////////////////////////////////////////////////////////////////////////
    944 // DesktopNativeWidgetAura, aura::WindowDelegate implementation:
    945 
    946 gfx::Size DesktopNativeWidgetAura::GetMinimumSize() const {
    947   return native_widget_delegate_->GetMinimumSize();
    948 }
    949 
    950 gfx::Size DesktopNativeWidgetAura::GetMaximumSize() const {
    951   return native_widget_delegate_->GetMaximumSize();
    952 }
    953 
    954 gfx::NativeCursor DesktopNativeWidgetAura::GetCursor(const gfx::Point& point) {
    955   return cursor_;
    956 }
    957 
    958 int DesktopNativeWidgetAura::GetNonClientComponent(
    959     const gfx::Point& point) const {
    960   return native_widget_delegate_->GetNonClientComponent(point);
    961 }
    962 
    963 bool DesktopNativeWidgetAura::ShouldDescendIntoChildForEventHandling(
    964       aura::Window* child,
    965       const gfx::Point& location) {
    966   views::WidgetDelegate* widget_delegate = GetWidget()->widget_delegate();
    967   return !widget_delegate ||
    968       widget_delegate->ShouldDescendIntoChildForEventHandling(child, location);
    969 }
    970 
    971 bool DesktopNativeWidgetAura::CanFocus() {
    972   return true;
    973 }
    974 
    975 void DesktopNativeWidgetAura::OnCaptureLost() {
    976   native_widget_delegate_->OnMouseCaptureLost();
    977 }
    978 
    979 void DesktopNativeWidgetAura::OnPaint(gfx::Canvas* canvas) {
    980   native_widget_delegate_->OnNativeWidgetPaint(canvas);
    981 }
    982 
    983 void DesktopNativeWidgetAura::OnDeviceScaleFactorChanged(
    984     float device_scale_factor) {
    985 }
    986 
    987 void DesktopNativeWidgetAura::OnWindowDestroying(aura::Window* window) {
    988   // Cleanup happens in OnHostClosed().
    989 }
    990 
    991 void DesktopNativeWidgetAura::OnWindowDestroyed(aura::Window* window) {
    992   // Cleanup happens in OnHostClosed(). We own |content_window_| (indirectly by
    993   // way of |dispatcher_|) so there should be no need to do any processing
    994   // here.
    995 }
    996 
    997 void DesktopNativeWidgetAura::OnWindowTargetVisibilityChanged(bool visible) {
    998 }
    999 
   1000 bool DesktopNativeWidgetAura::HasHitTestMask() const {
   1001   return native_widget_delegate_->HasHitTestMask();
   1002 }
   1003 
   1004 void DesktopNativeWidgetAura::GetHitTestMask(gfx::Path* mask) const {
   1005   native_widget_delegate_->GetHitTestMask(mask);
   1006 }
   1007 
   1008 ////////////////////////////////////////////////////////////////////////////////
   1009 // DesktopNativeWidgetAura, ui::EventHandler implementation:
   1010 
   1011 void DesktopNativeWidgetAura::OnKeyEvent(ui::KeyEvent* event) {
   1012   if (event->is_char()) {
   1013     // If a ui::InputMethod object is attached to the root window, character
   1014     // events are handled inside the object and are not passed to this function.
   1015     // If such object is not attached, character events might be sent (e.g. on
   1016     // Windows). In this case, we just skip these.
   1017     return;
   1018   }
   1019   // Renderer may send a key event back to us if the key event wasn't handled,
   1020   // and the window may be invisible by that time.
   1021   if (!content_window_->IsVisible())
   1022     return;
   1023 
   1024   native_widget_delegate_->OnKeyEvent(event);
   1025   if (event->handled())
   1026     return;
   1027 
   1028   if (GetWidget()->HasFocusManager() &&
   1029       !GetWidget()->GetFocusManager()->OnKeyEvent(*event))
   1030     event->SetHandled();
   1031 }
   1032 
   1033 void DesktopNativeWidgetAura::OnMouseEvent(ui::MouseEvent* event) {
   1034   DCHECK(content_window_->IsVisible());
   1035   if (tooltip_manager_.get())
   1036     tooltip_manager_->UpdateTooltip();
   1037   TooltipManagerAura::UpdateTooltipManagerForCapture(GetWidget());
   1038   native_widget_delegate_->OnMouseEvent(event);
   1039   // WARNING: we may have been deleted.
   1040 }
   1041 
   1042 void DesktopNativeWidgetAura::OnScrollEvent(ui::ScrollEvent* event) {
   1043   if (event->type() == ui::ET_SCROLL) {
   1044     native_widget_delegate_->OnScrollEvent(event);
   1045     if (event->handled())
   1046       return;
   1047 
   1048     // Convert unprocessed scroll events into wheel events.
   1049     ui::MouseWheelEvent mwe(*static_cast<ui::ScrollEvent*>(event));
   1050     native_widget_delegate_->OnMouseEvent(&mwe);
   1051     if (mwe.handled())
   1052       event->SetHandled();
   1053   } else {
   1054     native_widget_delegate_->OnScrollEvent(event);
   1055   }
   1056 }
   1057 
   1058 void DesktopNativeWidgetAura::OnGestureEvent(ui::GestureEvent* event) {
   1059   native_widget_delegate_->OnGestureEvent(event);
   1060 }
   1061 
   1062 ////////////////////////////////////////////////////////////////////////////////
   1063 // DesktopNativeWidgetAura, aura::client::ActivationDelegate implementation:
   1064 
   1065 bool DesktopNativeWidgetAura::ShouldActivate() const {
   1066   return native_widget_delegate_->CanActivate();
   1067 }
   1068 
   1069 ////////////////////////////////////////////////////////////////////////////////
   1070 // DesktopNativeWidgetAura, aura::client::ActivationChangeObserver
   1071 //    implementation:
   1072 
   1073 void DesktopNativeWidgetAura::OnWindowActivated(aura::Window* gained_active,
   1074                                                 aura::Window* lost_active) {
   1075   DCHECK(content_window_ == gained_active || content_window_ == lost_active);
   1076   if (gained_active == content_window_ && restore_focus_on_activate_) {
   1077     restore_focus_on_activate_ = false;
   1078     GetWidget()->GetFocusManager()->RestoreFocusedView();
   1079   } else if (lost_active == content_window_ && GetWidget()->HasFocusManager()) {
   1080     DCHECK(!restore_focus_on_activate_);
   1081     restore_focus_on_activate_ = true;
   1082     // Pass in false so that ClearNativeFocus() isn't invoked.
   1083     GetWidget()->GetFocusManager()->StoreFocusedView(false);
   1084   }
   1085 }
   1086 
   1087 ////////////////////////////////////////////////////////////////////////////////
   1088 // DesktopNativeWidgetAura, aura::client::FocusChangeObserver implementation:
   1089 
   1090 void DesktopNativeWidgetAura::OnWindowFocused(aura::Window* gained_focus,
   1091                                               aura::Window* lost_focus) {
   1092   if (content_window_ == gained_focus) {
   1093     desktop_window_tree_host_->OnNativeWidgetFocus();
   1094     native_widget_delegate_->OnNativeFocus(lost_focus);
   1095 
   1096     // If focus is moving from a descendant Window to |content_window_| then
   1097     // native activation hasn't changed. Still, the InputMethod must be informed
   1098     // of the Window focus change.
   1099     InputMethod* input_method = GetWidget()->GetInputMethod();
   1100     if (input_method)
   1101       input_method->OnFocus();
   1102   } else if (content_window_ == lost_focus) {
   1103     desktop_window_tree_host_->OnNativeWidgetBlur();
   1104     native_widget_delegate_->OnNativeBlur(gained_focus);
   1105   }
   1106 }
   1107 
   1108 ////////////////////////////////////////////////////////////////////////////////
   1109 // DesktopNativeWidgetAura, views::internal::InputMethodDelegate:
   1110 
   1111 void DesktopNativeWidgetAura::DispatchKeyEventPostIME(const ui::KeyEvent& key) {
   1112   FocusManager* focus_manager =
   1113       native_widget_delegate_->AsWidget()->GetFocusManager();
   1114   native_widget_delegate_->OnKeyEvent(const_cast<ui::KeyEvent*>(&key));
   1115   if (key.handled() || !focus_manager)
   1116     return;
   1117   focus_manager->OnKeyEvent(key);
   1118 }
   1119 
   1120 ////////////////////////////////////////////////////////////////////////////////
   1121 // DesktopNativeWidgetAura, aura::WindowDragDropDelegate implementation:
   1122 
   1123 void DesktopNativeWidgetAura::OnDragEntered(const ui::DropTargetEvent& event) {
   1124   DCHECK(drop_helper_.get() != NULL);
   1125   last_drop_operation_ = drop_helper_->OnDragOver(event.data(),
   1126       event.location(), event.source_operations());
   1127 }
   1128 
   1129 int DesktopNativeWidgetAura::OnDragUpdated(const ui::DropTargetEvent& event) {
   1130   DCHECK(drop_helper_.get() != NULL);
   1131   last_drop_operation_ = drop_helper_->OnDragOver(event.data(),
   1132       event.location(), event.source_operations());
   1133   return last_drop_operation_;
   1134 }
   1135 
   1136 void DesktopNativeWidgetAura::OnDragExited() {
   1137   DCHECK(drop_helper_.get() != NULL);
   1138   drop_helper_->OnDragExit();
   1139 }
   1140 
   1141 int DesktopNativeWidgetAura::OnPerformDrop(const ui::DropTargetEvent& event) {
   1142   DCHECK(drop_helper_.get() != NULL);
   1143   Activate();
   1144   return drop_helper_->OnDrop(event.data(), event.location(),
   1145       last_drop_operation_);
   1146 }
   1147 
   1148 ////////////////////////////////////////////////////////////////////////////////
   1149 // DesktopNativeWidgetAura, aura::WindowTreeHostObserver implementation:
   1150 
   1151 void DesktopNativeWidgetAura::OnHostCloseRequested(
   1152     const aura::WindowTreeHost* host) {
   1153   GetWidget()->Close();
   1154 }
   1155 
   1156 void DesktopNativeWidgetAura::OnHostResized(const aura::WindowTreeHost* host) {
   1157   // Don't update the bounds of the child layers when animating closed. If we
   1158   // did it would force a paint, which we don't want. We don't want the paint
   1159   // as we can't assume any of the children are valid.
   1160   if (desktop_window_tree_host_->IsAnimatingClosed())
   1161     return;
   1162 
   1163   gfx::Rect new_bounds = gfx::Rect(host->window()->bounds().size());
   1164   content_window_->SetBounds(new_bounds);
   1165   // Can be NULL at start.
   1166   if (content_window_container_)
   1167     content_window_container_->SetBounds(new_bounds);
   1168   native_widget_delegate_->OnNativeWidgetSizeChanged(new_bounds.size());
   1169 }
   1170 
   1171 void DesktopNativeWidgetAura::OnHostMoved(const aura::WindowTreeHost* host,
   1172                                           const gfx::Point& new_origin) {
   1173   TRACE_EVENT1("views", "DesktopNativeWidgetAura::OnHostMoved",
   1174                "new_origin", new_origin.ToString());
   1175 
   1176   native_widget_delegate_->OnNativeWidgetMove();
   1177 }
   1178 
   1179 ////////////////////////////////////////////////////////////////////////////////
   1180 // DesktopNativeWidgetAura, private:
   1181 
   1182 void DesktopNativeWidgetAura::InstallInputMethodEventFilter() {
   1183   DCHECK(!input_method_event_filter_.get());
   1184 
   1185   input_method_event_filter_.reset(new wm::InputMethodEventFilter(
   1186       host_->GetAcceleratedWidget()));
   1187   input_method_event_filter_->SetInputMethodPropertyInRootWindow(
   1188       host_->window());
   1189   root_window_event_filter_->AddHandler(input_method_event_filter_.get());
   1190 }
   1191 
   1192 void DesktopNativeWidgetAura::UpdateWindowTransparency() {
   1193   content_window_->SetTransparent(
   1194       desktop_window_tree_host_->ShouldWindowContentsBeTransparent());
   1195   // Regardless of transparency or not, this root content window will always
   1196   // fill its bounds completely, so set this flag to true to avoid an
   1197   // unecessary clear before update.
   1198   content_window_->SetFillsBoundsCompletely(true);
   1199 }
   1200 
   1201 void DesktopNativeWidgetAura::RootWindowDestroyed() {
   1202   cursor_reference_count_--;
   1203   if (cursor_reference_count_ == 0) {
   1204     // We are the last DesktopNativeWidgetAura instance, and we are responsible
   1205     // for cleaning up |cursor_manager_|.
   1206     delete cursor_manager_;
   1207     native_cursor_manager_ = NULL;
   1208     cursor_manager_ = NULL;
   1209   }
   1210 }
   1211 
   1212 }  // namespace views
   1213