arc: Support Arc window showing/hiding on a user's profile switch.

chrome/browser/ui/ash/launcher/arc_app_window_launcher_controller.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 "chrome/browser/ui/ash/launcher/arc_app_window_launcher_controller.h"
 
 #include <string>
 
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm/window_state.h"
@@ skipping 74 matching lines @@
       return blink::WebScreenOrientationLockAny;
   }
 }
 
 }  // namespace
 
 class ArcAppWindowLauncherController::AppWindow : public ui::BaseWindow {
  public:
   AppWindow(int task_id,
             const std::string app_id,
+            views::Widget* widget,

[khmel, 2016/09/14 23:42:19]

Setting widget is legacy code for one of the first arc window impl. Now it is
not required once Arc app has separate window. Moreover changing widget (and
native window) runtime is crash condition in controllers (problem with closing
windows for example).
Now it safe to discard it.

             ArcAppWindowLauncherController* owner)
-      : task_id_(task_id), app_id_(app_id), owner_(owner) {}
+      : task_id_(task_id), app_id_(app_id), widget_(widget), owner_(owner) {}
   ~AppWindow() {}
 
   void SetController(ArcAppWindowLauncherItemController* controller) {
     DCHECK(!controller_ && controller);
     controller_ = controller;
   }
 
   void ResetController() { controller_ = nullptr; }
 
   void SetFullscreenMode(FullScreenMode mode) {
     DCHECK(mode != FullScreenMode::NOT_DEFINED);
     fullscreen_mode_ = mode;
   }
 
   FullScreenMode fullscreen_mode() const { return fullscreen_mode_; }
 
   int task_id() const { return task_id_; }
 
   ash::ShelfID shelf_id() const { return shelf_id_; }
 
   void set_shelf_id(ash::ShelfID shelf_id) { shelf_id_ = shelf_id; }
 
   views::Widget* widget() const { return widget_; }
 
-  void set_widget(views::Widget* widget) { widget_ = widget; }
-
   ArcAppWindowLauncherItemController* controller() { return controller_; }
 
   const std::string app_id() { return app_id_; }
 
   // ui::BaseWindow:
   bool IsActive() const override {
-    return widget_ && widget_->IsActive() &&
-           owner_->active_task_id_ == task_id_;
+    return widget_->IsActive() && owner_->active_task_id_ == task_id_;
   }
 
   bool IsMaximized() const override {
     NOTREACHED();
     return false;
   }
 
   bool IsMinimized() const override {
     NOTREACHED();
     return false;
   }
 
   bool IsFullscreen() const override {
     NOTREACHED();
     return false;
   }
 
   gfx::NativeWindow GetNativeWindow() const override {
-    return widget_ ? widget_->GetNativeWindow() : nullptr;
+    return widget_->GetNativeWindow();
   }
 
   gfx::Rect GetRestoredBounds() const override {
     NOTREACHED();
     return gfx::Rect();
   }
 
   ui::WindowShowState GetRestoredState() const override {
     NOTREACHED();
     return ui::SHOW_STATE_NORMAL;
   }
 
   gfx::Rect GetBounds() const override {
     NOTREACHED();
     return gfx::Rect();
   }
 
-  void Show() override {
-    // TODO(khmel): support window minimizing.
-  }
+  void Show() override { widget_->Show(); }

[khmel, 2016/09/14 23:42:19]

This is needed to correctly restore from clicking on shelf items in several
cases.

 
   void ShowInactive() override { NOTREACHED(); }
 
   void Hide() override { NOTREACHED(); }
 
   void Close() override { arc::CloseTask(task_id_); }
 
-  void Activate() override { arc::SetTaskActive(task_id_); }
+  void Activate() override { widget_->Activate(); }

[khmel, 2016/09/14 23:42:19]

As discussed let use wayland protocol whenever possible.

 
   void Deactivate() override { NOTREACHED(); }
 
   void Maximize() override { NOTREACHED(); }
 
-  void Minimize() override {
-    if (widget_)
-      widget_->Minimize();
-  }
+  void Minimize() override { widget_->Minimize(); }
 
   void Restore() override { NOTREACHED(); }
 
   void SetBounds(const gfx::Rect& bounds) override { NOTREACHED(); }
 
   void FlashFrame(bool flash) override { NOTREACHED(); }
 
   bool IsAlwaysOnTop() const override {
     NOTREACHED();
     return false;
@@ skipping 13 matching lines @@
   bool has_requested_orientation_lock() const {
     return has_requested_orientation_lock_;
   }
 
  private:
   int task_id_;
   ash::ShelfID shelf_id_ = 0;
   std::string app_id_;
   FullScreenMode fullscreen_mode_ = FullScreenMode::NOT_DEFINED;
   // Unowned pointers
+  views::Widget* widget_;

[Mr4D (OOO till 08-26), 2016/09/15 14:03:19]

could this be then const?

[khmel, 2016/09/15 15:43:27]

Indeed

   ArcAppWindowLauncherController* owner_;
   ArcAppWindowLauncherItemController* controller_ = nullptr;
   // Unowned pointer, represents host Arc window.
-  views::Widget* widget_ = nullptr;
 
   arc::mojom::OrientationLock requested_orientation_lock_ =
       arc::mojom::OrientationLock::NONE;
   bool has_requested_orientation_lock_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(AppWindow);
 };
 
 ArcAppWindowLauncherController::ArcAppWindowLauncherController(
     ChromeLauncherController* owner,
@@ skipping 54 matching lines @@
 }
 
 void ArcAppWindowLauncherController::OnWindowInitialized(aura::Window* window) {
   // Arc windows has type WINDOW_TYPE_NORMAL.
   if (window->type() != ui::wm::WINDOW_TYPE_NORMAL)
     return;
   observed_windows_.push_back(window);
   window->AddObserver(this);
 }
 
-void ArcAppWindowLauncherController::OnWindowVisibilityChanging(
+void ArcAppWindowLauncherController::OnWindowVisibilityChanged(

[khmel, 2016/09/14 23:42:19]

Quite tricky case. We used OnWindowVisibilityChanging event to attach controller
to window. This also registers window in multi user manager. Although window is
changing to visible, it is visible status is still off. Multi-user manager
stores its current status which is off. Of cause it sets window observer and
listen the same OnWindowVisibilityChanging. It is not called for new listener
and multi user manager thinks that Arc window is invisible. When we switch user
to primary profile back, multi user window does not show our window.

[Mr4D (OOO till 08-26), 2016/09/15 14:03:19]

You might want to add a comment here towards that. Just to make sure that a
viewer of the codes does understand why you use this and not the other.

[khmel, 2016/09/15 15:43:27]

Done.

     aura::Window* window,
     bool visible) {
   // The application id property should be set at this time.
   if (visible && observed_profile_ == owner()->GetProfile())
     AttachControllerToWindowIfNeeded(window);
 }
 
 void ArcAppWindowLauncherController::OnWindowDestroying(aura::Window* window) {
   auto it =
       std::find(observed_windows_.begin(), observed_windows_.end(), window);
@@ skipping 53 matching lines @@
   if (GetAppWindowForTask(task_id))
     return;
 
   // Create controller if we have task info.
   TaskIdToShelfAppIdMap::iterator it = task_id_to_shelf_app_id_.find(task_id);
   if (it == task_id_to_shelf_app_id_.end())
     return;
 
   const std::string& app_id = it->second;
 
-  std::unique_ptr<AppWindow> app_window(new AppWindow(task_id, app_id, this));
-  app_window->set_widget(views::Widget::GetWidgetForNativeWindow(window));
+  views::Widget* widget = views::Widget::GetWidgetForNativeWindow(window);
+  DCHECK(widget);
+  std::unique_ptr<AppWindow> app_window(
+      new AppWindow(task_id, app_id, widget, this));
   RegisterApp(app_window.get());
   DCHECK(app_window->controller());
   ash::SetShelfIDForWindow(app_window->shelf_id(), window);
   chrome::MultiUserWindowManager::GetInstance()->SetWindowOwner(
       window,
       user_manager::UserManager::Get()->GetPrimaryUser()->GetAccountId());
   if (ash::WmShell::Get()
           ->maximize_mode_controller()
           ->IsMaximizeModeWindowManagerEnabled()) {
     SetOrientationLockForAppWindow(app_window.get());
@@ skipping 251 matching lines @@
   if (orientation_lock == arc::mojom::OrientationLock::CURRENT) {
     // Resolve the orientation when it first resolved.
     orientation_lock = GetCurrentOrientation();
     app_window->set_requested_orientation_lock(orientation_lock);
   }
 
   ash::Shell* shell = ash::Shell::GetInstance();
   shell->screen_orientation_controller()->LockOrientationForWindow(
       window, BlinkOrientationLockFromMojom(orientation_lock));
 }