Couple of fixes for DesktopWindowTreeHostMus.

ui/views/mus/desktop_window_tree_host_mus.cc

 // Copyright 2016 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/mus/desktop_window_tree_host_mus.h"
 
 #include "base/memory/ptr_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/drag_drop_client.h"
 #include "ui/aura/client/focus_client.h"
@@ skipping 28 matching lines @@
   aura::Env::GetInstance()->RemoveObserver(this);
   desktop_native_widget_aura_->OnDesktopWindowTreeHostDestroyed(this);
 }
 
 bool DesktopWindowTreeHostMus::IsDocked() const {
   return window()->GetProperty(aura::client::kShowStateKey) ==
          ui::SHOW_STATE_DOCKED;
 }
 
 void DesktopWindowTreeHostMus::Init(aura::Window* content_window,
-                                    const Widget::InitParams& params) {}
+                                    const Widget::InitParams& params) {
+  // TODO: handle device scale, http://crbug.com/663524.
+  if (!params.bounds.IsEmpty())
+    SetBounds(params.bounds);
+}
 
 void DesktopWindowTreeHostMus::OnNativeWidgetCreated(
     const Widget::InitParams& params) {
   if (params.parent && params.parent->GetHost()) {
     parent_ = static_cast<DesktopWindowTreeHostMus*>(params.parent->GetHost());
     parent_->children_.insert(this);
   }
   native_widget_delegate_->OnNativeWidgetCreated(true);
 }
 
@@ skipping 43 matching lines @@
 }
 
 void DesktopWindowTreeHostMus::ShowWindowWithState(ui::WindowShowState state) {
   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 (compositor())
     compositor()->SetVisible(true);
-  // TODO: likely needs code to activate, but after content_window_ is shown.
-  // See NativeWidgetAura::ShowWithWindowState().
+
+  if (native_widget_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.
+    // Activate() might fail if the window is non-activatable. In this case, we
+    // should pass SHOW_STATE_INACTIVE to SetInitialFocus() to stop the initial
+    // focused view from getting focused. See crbug.com/515594 for example.
+    native_widget_delegate_->SetInitialFocus(
+        IsActive() ? state : ui::SHOW_STATE_INACTIVE);
+  }
 }
 
 void DesktopWindowTreeHostMus::ShowMaximizedWithBounds(
     const gfx::Rect& restored_bounds) {
   window()->SetProperty(aura::client::kRestoreBoundsKey,
                         new gfx::Rect(restored_bounds));
   ShowWindowWithState(ui::SHOW_STATE_MAXIMIZED);
 }
 
 bool DesktopWindowTreeHostMus::IsVisible() const {
@@ skipping 20 matching lines @@
   // TODO: implement window stacking, http://crbug.com/663617.
   NOTIMPLEMENTED();
 }
 
 void DesktopWindowTreeHostMus::StackAtTop() {
   // TODO: implement window stacking, http://crbug.com/663617.
   NOTIMPLEMENTED();
 }
 
 void DesktopWindowTreeHostMus::CenterWindow(const gfx::Size& size) {
-  NOTIMPLEMENTED();
+  gfx::Rect bounds_to_center_in = GetWorkAreaBoundsInScreen();
+
+  // If there is a transient parent and it fits |size|, then center over it.
+  aura::Window* content_window = desktop_native_widget_aura_->content_window();
+  if (wm::GetTransientParent(content_window)) {
+    gfx::Rect transient_parent_bounds =
+        wm::GetTransientParent(content_window)->GetBoundsInScreen();
+    if (transient_parent_bounds.height() >= size.height() &&
+        transient_parent_bounds.width() >= size.width()) {
+      bounds_to_center_in = transient_parent_bounds;
+    }
+  }
+
+  gfx::Rect resulting_bounds(bounds_to_center_in);
+  resulting_bounds.ClampToCenteredSize(size);
+
+  // TODO: handle device scale, http://crbug.com/663524. SetBounds() expects
+  // pixels.
+  SetBounds(resulting_bounds);
 }
 
 void DesktopWindowTreeHostMus::GetWindowPlacement(
     gfx::Rect* bounds,
     ui::WindowShowState* show_state) const {
   // Implementation matches that of NativeWidgetAura.
   *bounds = GetRestoredBounds();
   *show_state = window()->GetProperty(aura::client::kShowStateKey);
 }
 
@@ skipping 88 matching lines @@
   return window()->GetProperty(aura::client::kShowStateKey) ==
          ui::SHOW_STATE_MAXIMIZED;
 }
 
 bool DesktopWindowTreeHostMus::IsMinimized() const {
   return window()->GetProperty(aura::client::kShowStateKey) ==
          ui::SHOW_STATE_MINIMIZED;
 }
 
 bool DesktopWindowTreeHostMus::HasCapture() const {
-  return const_cast<aura::Window*>(window())->HasCapture();
+  // Capture state is held by DesktopNativeWidgetAura::content_window_.
+  // DesktopNativeWidgetAura::HasCapture() calls content_window_->HasCapture(),
+  // and this. That means this function can always return true.
+  return true;
 }
 
 void DesktopWindowTreeHostMus::SetAlwaysOnTop(bool always_on_top) {
   window()->SetProperty(aura::client::kAlwaysOnTopKey, always_on_top);
 }
 
 bool DesktopWindowTreeHostMus::IsAlwaysOnTop() const {
   return window()->GetProperty(aura::client::kAlwaysOnTopKey);
 }
 
@@ skipping 140 matching lines @@
   if (window == this->window()) {
     is_active_ = true;
     desktop_native_widget_aura_->HandleActivationChanged(true);
   } else if (is_active_) {
     is_active_ = false;
     desktop_native_widget_aura_->HandleActivationChanged(false);
   }
 }
 
 }  // namespace views