Fixes a couple of bugs in NativeWidgetMus

ui/views/mus/native_widget_mus.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/views/mus/native_widget_mus.h"
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 354 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(EventAckHandler);
 };
 
 void OnMoveLoopEnd(bool* out_success,
                    base::Closure quit_closure,
                    bool in_success) {
   *out_success = in_success;
   quit_closure.Run();
 }
 
+ui::mojom::ShowState GetShowState(const ui::Window* window) {
+  if (!window ||
+      !window->HasSharedProperty(
+          ui::mojom::WindowManager::kShowState_Property)) {
+    return ui::mojom::ShowState::DEFAULT;
+  }
+
+  return static_cast<ui::mojom::ShowState>(window->GetSharedProperty<int32_t>(
+      ui::mojom::WindowManager::kShowState_Property));
+}
+
 }  // namespace
 
 class NativeWidgetMus::MusWindowObserver : public ui::WindowObserver {
  public:
   explicit MusWindowObserver(NativeWidgetMus* native_widget_mus)
       : native_widget_mus_(native_widget_mus),
         show_state_(ui::mojom::ShowState::DEFAULT) {
     mus_window()->AddObserver(this);
   }
 
   ~MusWindowObserver() override {
     mus_window()->RemoveObserver(this);
   }
 
-  ui::mojom::ShowState show_state() { return show_state_; }
-
   // ui::WindowObserver:
   void OnWindowVisibilityChanging(ui::Window* window) override {
     native_widget_mus_->OnMusWindowVisibilityChanging(window);
   }
   void OnWindowVisibilityChanged(ui::Window* window) override {
     native_widget_mus_->OnMusWindowVisibilityChanged(window);
   }
   void OnWindowPredefinedCursorChanged(ui::Window* window,
                                        ui::mojom::Cursor cursor) override {
     DCHECK_EQ(window, mus_window());
     native_widget_mus_->set_last_cursor(cursor);
   }
   void OnWindowSharedPropertyChanged(
       ui::Window* window,
       const std::string& name,
       const std::vector<uint8_t>* old_data,
       const std::vector<uint8_t>* new_data) override {
     if (name != ui::mojom::WindowManager::kShowState_Property)
       return;
-    ui::mojom::ShowState show_state =
-        static_cast<ui::mojom::ShowState>(window->GetSharedProperty<int32_t>(
-            ui::mojom::WindowManager::kShowState_Property));
+    const ui::mojom::ShowState show_state = GetShowState(window);
     if (show_state == show_state_)
       return;
     show_state_ = show_state;
     ui::PlatformWindowState state = ui::PLATFORM_WINDOW_STATE_UNKNOWN;
     switch (show_state_) {
       case ui::mojom::ShowState::MINIMIZED:
         state = ui::PLATFORM_WINDOW_STATE_MINIMIZED;
         break;
       case ui::mojom::ShowState::MAXIMIZED:
         state = ui::PLATFORM_WINDOW_STATE_MAXIMIZED;
@@ skipping 79 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetMus, public:
 
 NativeWidgetMus::NativeWidgetMus(internal::NativeWidgetDelegate* delegate,
                                  ui::Window* window,
                                  ui::mojom::SurfaceType surface_type)
     : window_(window),
       last_cursor_(ui::mojom::Cursor::CURSOR_NULL),
       native_widget_delegate_(delegate),
-      surface_type_(surface_type),
+      is_parallel_widget_in_window_manager_(surface_type ==
+                                            ui::mojom::SurfaceType::UNDERLAY),
       show_state_before_fullscreen_(ui::mojom::ShowState::DEFAULT),
       ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET),
       content_(new aura::Window(this)),
       close_widget_factory_(this) {
   window_->set_input_event_handler(this);
   mus_window_observer_.reset(new MusWindowObserver(this));
 
   // TODO(fsamuel): Figure out lifetime of |window_|.
   aura::SetMusWindow(content_, window_);
   window->SetLocalProperty(kNativeWidgetMusKey, this);
 
   // WindowTreeHost creates the compositor using the ContextFactory from
   // aura::Env. Install |context_factory_| there so that |context_factory_| is
   // picked up.
   ui::ContextFactory* default_context_factory =
       aura::Env::GetInstance()->context_factory();
   if (!default_context_factory) {
-    context_factory_.reset(new SurfaceContextFactory(window_, surface_type_));
+    context_factory_.reset(new SurfaceContextFactory(window_, surface_type));
     aura::Env::GetInstance()->set_context_factory(context_factory_.get());
   }
 
   window_tree_host_.reset(new WindowTreeHostMus(this, window_));
   aura::Env::GetInstance()->set_context_factory(default_context_factory);
 }
 
 NativeWidgetMus::~NativeWidgetMus() {
   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET) {
     DCHECK(!window_);
@@ skipping 62 matching lines @@
     native_widget_delegate_->OnNativeFocus();
     GetWidget()->GetFocusManager()->RestoreFocusedView();
   } else {
     native_widget_delegate_->OnNativeBlur();
     GetWidget()->GetFocusManager()->StoreFocusedView(true);
   }
   native_widget_delegate_->OnNativeWidgetActivationChanged(active);
 }
 
 void NativeWidgetMus::UpdateClientArea() {
+  if (is_parallel_widget_in_window_manager())
+    return;
+
   NonClientView* non_client_view =
       native_widget_delegate_->AsWidget()->non_client_view();
   if (!non_client_view || !non_client_view->client_view())
     return;
 
   const gfx::Rect client_area_rect(non_client_view->client_view()->bounds());
   window_->SetClientArea(gfx::Insets(
       client_area_rect.y(), client_area_rect.x(),
       non_client_view->bounds().height() - client_area_rect.bottom(),
       non_client_view->bounds().width() - client_area_rect.right()));
@@ skipping 18 matching lines @@
   }
   (*properties)[ui::mojom::WindowManager::kAlwaysOnTop_Property] =
       mojo::ConvertTo<std::vector<uint8_t>>(init_params.keep_on_top);
 
   if (!Widget::RequiresNonClientView(init_params.type))
     return;
 
   (*properties)[ui::mojom::WindowManager::kWindowType_Property] =
       mojo::ConvertTo<std::vector<uint8_t>>(static_cast<int32_t>(
           mojo::ConvertTo<ui::mojom::WindowType>(init_params.type)));
-  if (!init_params.delegate &&
+  if (init_params.delegate &&
       properties->count(ui::mojom::WindowManager::kResizeBehavior_Property) ==
           0) {
     (*properties)[ui::mojom::WindowManager::kResizeBehavior_Property] =
         mojo::ConvertTo<std::vector<uint8_t>>(
             ResizeBehaviorFromDelegate(init_params.delegate));
   }
   SkBitmap app_icon = AppIconFromDelegate(init_params.delegate);
   if (!app_icon.isNull()) {
     (*properties)[ui::mojom::WindowManager::kWindowAppIcon_Property] =
         mojo::ConvertTo<std::vector<uint8_t>>(app_icon);
@@ skipping 25 matching lines @@
 
   aura::client::SetFocusClient(hosted_window, focus_client_.get());
   aura::client::SetActivationClient(hosted_window, focus_client_.get());
   screen_position_client_.reset(new ScreenPositionClientMus(window_));
   aura::client::SetScreenPositionClient(hosted_window,
                                         screen_position_client_.get());
 
   // TODO(erg): Remove this check when ash/mus/frame/move_event_handler.cc's
   // direct usage of ui::Window::SetPredefinedCursor() is switched to a
   // private method on WindowManagerClient.
-  if (surface_type_ == ui::mojom::SurfaceType::DEFAULT) {
+  if (!is_parallel_widget_in_window_manager()) {
     cursor_manager_.reset(new wm::CursorManager(
         base::WrapUnique(new NativeCursorManagerMus(window_))));
     aura::client::SetCursorClient(hosted_window, cursor_manager_.get());
   }
 
   window_tree_client_.reset(new NativeWidgetMusWindowTreeClient(hosted_window));
   hosted_window->AddPreTargetHandler(focus_client_.get());
   hosted_window->SetLayoutManager(
       new ContentWindowLayoutManager(hosted_window, content_));
   capture_client_.reset(new MusCaptureClient(hosted_window, content_, window_));
@@ skipping 119 matching lines @@
 
 bool NativeWidgetMus::HasCapture() const {
   return content_ && content_->HasCapture();
 }
 
 ui::InputMethod* NativeWidgetMus::GetInputMethod() {
   return window_tree_host_ ? window_tree_host_->GetInputMethod() : nullptr;
 }
 
 void NativeWidgetMus::CenterWindow(const gfx::Size& size) {
+  if (is_parallel_widget_in_window_manager())
+    return;
   // TODO(beng): clear user-placed property and set preferred size property.
   window_->SetSharedProperty<gfx::Size>(
       ui::mojom::WindowManager::kPreferredSize_Property, size);
 
   gfx::Rect bounds = display::Screen::GetScreen()
                          ->GetDisplayNearestWindow(content_)
                          .work_area();
   bounds.ClampToCenteredSize(size);
   window_->SetBounds(bounds);
 }
 
 void NativeWidgetMus::GetWindowPlacement(
       gfx::Rect* bounds,
       ui::WindowShowState* maximized) const {
   // NOTIMPLEMENTED();
 }
 
 bool NativeWidgetMus::SetWindowTitle(const base::string16& title) {
-  if (!window_)
+  if (!window_ || is_parallel_widget_in_window_manager())
     return false;
   const char* kWindowTitle_Property =
       ui::mojom::WindowManager::kWindowTitle_Property;
   const base::string16 current_title =
       window_->HasSharedProperty(kWindowTitle_Property)
           ? window_->GetSharedProperty<base::string16>(kWindowTitle_Property)
           : base::string16();
   if (current_title == title)
     return false;
   window_->SetSharedProperty<base::string16>(kWindowTitle_Property, title);
   return true;
 }
 
 void NativeWidgetMus::SetWindowIcons(const gfx::ImageSkia& window_icon,
                                      const gfx::ImageSkia& app_icon) {
+  if (is_parallel_widget_in_window_manager())
+    return;
+
   const char* const kWindowAppIcon_Property =
       ui::mojom::WindowManager::kWindowAppIcon_Property;
 
   if (!app_icon.isNull()) {
     // Send the app icon 1x bitmap to the window manager.
     // TODO(jamescook): Support other scale factors.
     window_->SetSharedProperty<SkBitmap>(
         kWindowAppIcon_Property, app_icon.GetRepresentation(1.f).sk_bitmap());
   } else if (window_->HasSharedProperty(kWindowAppIcon_Property)) {
     // Remove the existing icon.
@@ skipping 169 matching lines @@
 
 void NativeWidgetMus::Maximize() {
   SetShowState(ui::mojom::ShowState::MAXIMIZED);
 }
 
 void NativeWidgetMus::Minimize() {
   SetShowState(ui::mojom::ShowState::MINIMIZED);
 }
 
 bool NativeWidgetMus::IsMaximized() const {
-  return mus_window_observer_ &&
-         mus_window_observer_->show_state() == ui::mojom::ShowState::MAXIMIZED;
+  return GetShowState(window_) == ui::mojom::ShowState::MAXIMIZED;
 }
 
 bool NativeWidgetMus::IsMinimized() const {
-  return mus_window_observer_ &&
-         mus_window_observer_->show_state() == ui::mojom::ShowState::MINIMIZED;
+  return GetShowState(window_) == ui::mojom::ShowState::MINIMIZED;
 }
 
 void NativeWidgetMus::Restore() {
   SetShowState(ui::mojom::ShowState::NORMAL);
 }
 
 void NativeWidgetMus::SetFullscreen(bool fullscreen) {
   if (IsFullscreen() == fullscreen)
     return;
   if (fullscreen) {
-    show_state_before_fullscreen_ = mus_window_observer_->show_state();
+    show_state_before_fullscreen_ = GetShowState(window_);
     // TODO(markdittmer): Fullscreen not implemented in ui::Window.
   } else {
     switch (show_state_before_fullscreen_) {
       case ui::mojom::ShowState::MAXIMIZED:
         Maximize();
         break;
       case ui::mojom::ShowState::MINIMIZED:
         Minimize();
         break;
       case ui::mojom::ShowState::DEFAULT:
       case ui::mojom::ShowState::NORMAL:
       case ui::mojom::ShowState::INACTIVE:
       case ui::mojom::ShowState::FULLSCREEN:
       case ui::mojom::ShowState::DOCKED:
         // TODO(sad): This may not be sufficient.
         Restore();
         break;
     }
   }
 }
 
 bool NativeWidgetMus::IsFullscreen() const {
-  return mus_window_observer_ &&
-         mus_window_observer_->show_state() == ui::mojom::ShowState::FULLSCREEN;
+  return GetShowState(window_) == ui::mojom::ShowState::FULLSCREEN;
 }
 
 void NativeWidgetMus::SetOpacity(float opacity) {
   if (window_)
     window_->SetOpacity(opacity);
 }
 
 void NativeWidgetMus::FlashFrame(bool flash_frame) {
   // NOTIMPLEMENTED();
 }
@@ skipping 102 matching lines @@
 void NativeWidgetMus::OnRootViewLayout() {
   // NOTIMPLEMENTED();
 }
 
 bool NativeWidgetMus::IsTranslucentWindowOpacitySupported() const {
   // NOTIMPLEMENTED();
   return true;
 }
 
 void NativeWidgetMus::OnSizeConstraintsChanged() {
-  if (!window_)
+  if (!window_ || is_parallel_widget_in_window_manager())
     return;
 
   window_->SetSharedProperty<int32_t>(
       ui::mojom::WindowManager::kResizeBehavior_Property,
       ResizeBehaviorFromDelegate(GetWidget()->widget_delegate()));
 }
 
 void NativeWidgetMus::RepostNativeEvent(gfx::NativeEvent native_event) {
   // NOTIMPLEMENTED();
 }
@@ skipping 169 matching lines @@
   } else {
     window_tree_host_->Hide();
     GetNativeWindow()->Hide();
   }
   native_widget_delegate_->OnNativeWidgetVisibilityChanged(window->visible());
 }
 
 void NativeWidgetMus::UpdateHitTestMask() {
   // The window manager (or other underlay window provider) is not allowed to
   // set a hit test mask, as that could interfere with a client app mask.
-  if (surface_type_ == ui::mojom::SurfaceType::UNDERLAY)
+  if (is_parallel_widget_in_window_manager())

[sadrul, 2016/08/08 20:31:21]

SWould it make sense to override these from WmNativeWidgetMus to be no-ops
instead?

[sky, 2016/08/08 21:10:43]

I have certainly done that, but it's very subtle and easy to miss. I though it
would be less mysterious to have the code here.

     return;
 
   if (!native_widget_delegate_->HasHitTestMask()) {
     window_->ClearHitTestMask();
     return;
   }
 
   gfx::Path mask_path;
   native_widget_delegate_->GetHitTestMask(&mask_path);
   // TODO(jamescook): Use the full path for the mask.
   gfx::Rect mask_rect =
       gfx::ToEnclosingRect(gfx::SkRectToRectF(mask_path.getBounds()));
   window_->SetHitTestMask(mask_rect);
 }
 
 }  // namespace views