Introduce system_info as an independent container.

athena/system/system_ui_impl.cc

 // Copyright 2014 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 "athena/system/public/system_ui.h"
 
 #include "athena/screen/public/screen_manager.h"
 #include "athena/system/background_controller.h"
 #include "athena/system/orientation_controller.h"
 #include "athena/system/shutdown_dialog.h"
 #include "athena/system/status_icon_container_view.h"
 #include "athena/system/time_view.h"
+#include "athena/util/athena_constants.h"
 #include "athena/util/container_priorities.h"
 #include "athena/util/fill_layout_manager.h"
+#include "athena/wm/public/window_manager.h"
+#include "athena/wm/public/window_manager_observer.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/aura/window.h"
+#include "ui/compositor/closure_animation_observer.h"
+#include "ui/compositor/layer.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
+#include "ui/gfx/animation/tween.h"
+#include "ui/gfx/transform.h"
 #include "ui/views/view.h"
+#include "ui/views/widget/widget.h"
 
 namespace athena {
 namespace {
 
 SystemUI* instance = nullptr;
 
+void ClearSystemInfo(views::Widget* widget) {
+  aura::Window* container = widget->GetNativeWindow()->parent();
+  container->Hide();
+  container->parent()->RemoveChild(container);
+  delete container;
+}
+
 // View which positions the TimeView on the left and the StatusIconView on the
 // right.
 class SystemInfoView : public views::View {
  public:
   SystemInfoView(SystemUI::ColorScheme color_scheme)
       : time_view_(new TimeView(color_scheme)),
         status_icon_view_(new StatusIconContainerView(color_scheme)) {
     AddChildView(time_view_);
     AddChildView(status_icon_view_);
   }
@@ skipping 26 matching lines @@
     Layout();
   }
 
  private:
   views::View* time_view_;
   views::View* status_icon_view_;
 
   DISALLOW_COPY_AND_ASSIGN(SystemInfoView);
 };
 
-class SystemUIImpl : public SystemUI {
+class SystemUIImpl : public SystemUI, public WindowManagerObserver {
  public:
   SystemUIImpl(scoped_refptr<base::TaskRunner> blocking_task_runner)
       : orientation_controller_(new OrientationController()),
-        background_container_(nullptr) {
+        background_container_(nullptr),
+        system_info_widget_(nullptr) {
     orientation_controller_->InitWith(blocking_task_runner);
+    WindowManager::Get()->AddObserver(this);
   }
 
   ~SystemUIImpl() override {
+    WindowManager::Get()->RemoveObserver(this);
+
     // Stops file watching now if exists. Waiting until message loop shutdon
     // leads to FilePathWatcher crash.
     orientation_controller_->Shutdown();
   }
 
   void Init() {
     ScreenManager* screen_manager = ScreenManager::Get();
     background_container_ = screen_manager->CreateContainer(
         ScreenManager::ContainerParams("AthenaBackground", CP_BACKGROUND));
     background_container_->SetLayoutManager(
         new FillLayoutManager(background_container_));
 
     shutdown_dialog_.reset(new ShutdownDialog());
     background_controller_.reset(
         new BackgroundController(background_container_));
   }
 
  private:
   // SystemUI:
-  virtual void SetBackgroundImage(const gfx::ImageSkia& image) override {
+  void SetBackgroundImage(const gfx::ImageSkia& image) override {
     background_controller_->SetImage(image);
   }
 
-  virtual views::View* CreateSystemInfoView(ColorScheme color_scheme) override {
-    return new SystemInfoView(color_scheme);
+  // WindowManagerObserver:
+  void OnOverviewModeEnter() override {
+    DCHECK(!system_info_widget_);
+
+    ScreenManager* screen_manager = ScreenManager::Get();
+    aura::Window* container = screen_manager->CreateContainer(
+        ScreenManager::ContainerParams("SystemInfo", CP_SYSTEM_INFO));
+
+    system_info_widget_ = new views::Widget();
+    views::Widget::InitParams widget_params(
+        views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
+    widget_params.parent = container;
+    widget_params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
+    widget_params.bounds =
+        gfx::Rect(0, 0, container->bounds().width(), kSystemUIHeight);
+    system_info_widget_->Init(widget_params);
+    system_info_widget_->SetContentsView(
+        new SystemInfoView(SystemUI::COLOR_SCHEME_LIGHT));
+    system_info_widget_->Show();
+
+    gfx::Transform transform;
+    transform.Translate(0, SkMScalar(-kSystemUIHeight));
+    system_info_widget_->GetLayer()->SetTransform(transform);
+
+    {
+      ui::ScopedLayerAnimationSettings settings(
+          system_info_widget_->GetLayer()->GetAnimator());
+      settings.SetTweenType(gfx::Tween::EASE_OUT);
+      system_info_widget_->GetLayer()->SetTransform(gfx::Transform());
+    }
   }
 
+  void OnOverviewModeExit() override {
+    ui::ScopedLayerAnimationSettings settings(
+        system_info_widget_->GetLayer()->GetAnimator());
+    settings.SetTweenType(gfx::Tween::EASE_IN);
+    gfx::Transform transform;
+    transform.Translate(0, SkIntToMScalar(-kSystemUIHeight));
+    system_info_widget_->GetLayer()->SetTransform(transform);
+    settings.AddObserver(new ui::ClosureAnimationObserver(
+        base::Bind(&ClearSystemInfo, system_info_widget_)));

[oshima, 2014/11/12 20:35:03]

It's probably better to use ScopedHidingAnimatinoSettings, and pass the
container instead.

And what if the root window is deleted during the animation? Will this be
aborted?

[Jun Mukai, 2014/11/12 21:39:58]

Removed the the code around here and replaced by ui/wm/core/window_animations
utilities.  PTAL.

+    system_info_widget_ = nullptr;
+  }
+
+  void OnSplitViewModeEnter() override {}
+
+  void OnSplitViewModeExit() override {}
+
   scoped_ptr<OrientationController> orientation_controller_;
   scoped_ptr<ShutdownDialog> shutdown_dialog_;
   scoped_ptr<BackgroundController> background_controller_;
 
   // The parent container for the background.
   aura::Window* background_container_;
 
-  // The parent container used by system modal dialogs.
-  aura::Window* system_modal_container_;
-
-  // The parent container used by system modal dialogs when the login screen is
-  // visible.
-  aura::Window* login_screen_system_modal_container_;
+  views::Widget* system_info_widget_;
 
   DISALLOW_COPY_AND_ASSIGN(SystemUIImpl);
 };
 
 }  // namespace
 
 // static
 SystemUI* SystemUI::Create(
     scoped_refptr<base::TaskRunner> blocking_task_runner) {
   SystemUIImpl* system_ui = new SystemUIImpl(blocking_task_runner);
   instance = system_ui;
   system_ui->Init();
   return instance;
 }
 
 // static
 SystemUI* SystemUI::Get() {
   DCHECK(instance);
   return instance;
 }
 
 // static
 void SystemUI::Shutdown() {
   CHECK(instance);
   delete instance;
   instance = nullptr;
 }
 
 }  // namespace athena