mash: Create and show a shelf in mash.

ash/shelf/shelf_widget.cc

 // Copyright 2012 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 "ash/shelf/shelf_widget.h"
 
-#include "ash/aura/wm_shelf_aura.h"

[James Cook, 2016/08/16 23:21:35]

Awesome.

[msw, 2016/08/17 01:09:02]

Acknowledged.

 #include "ash/common/focus_cycler.h"
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_background_animator_observer.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/shelf/shelf_view.h"
 #include "ash/common/shelf/wm_dimmer_view.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shelf/wm_shelf_util.h"
@@ skipping 130 matching lines @@
 
 ShelfWidget::DelegateView::~DelegateView() {
   // Make sure that the dimmer goes away since it might have set an observer.
   SetDimmed(false);
 }
 
 void ShelfWidget::DelegateView::SetDimmed(bool dimmed) {
   // When starting dimming, attempt to create a dimmer view.
   if (dimmed) {
     if (!dimmer_view_) {
-      // The WmShelf interface is private in WmShelfAura.
-      WmShelf* shelf = static_cast<WmShelf*>(shelf_widget_->wm_shelf_aura_);
       dimmer_view_ =
-          shelf->CreateDimmerView(disable_dimming_animations_for_test_);
+          wm_shelf_->CreateDimmerView(disable_dimming_animations_for_test_);
     }
     return;
   }
 
   // Close the dimmer widget when stopping dimming.
   if (dimmer_view_) {
     dimmer_view_->GetDimmerWidget()->CloseNow();
     dimmer_view_ = nullptr;
   }
 }
@@ skipping 111 matching lines @@
   opaque_background_.SetOpacity(alpha / kMaxAlpha);
 }
 
 void ShelfWidget::DelegateView::UpdateShelfAssetBackground(int alpha) {
   asset_background_alpha_ = alpha;
   SchedulePaint();
 }
 
 ShelfWidget::ShelfWidget(WmWindow* shelf_container,
                          WmWindow* status_container,
-                         WmShelfAura* wm_shelf_aura)
-    : wm_shelf_aura_(wm_shelf_aura),
+                         WmShelf* wm_shelf)
+    : wm_shelf_(wm_shelf),
       shelf_(nullptr),
-      delegate_view_(new DelegateView(wm_shelf_aura, this)),
+      delegate_view_(new DelegateView(wm_shelf, this)),
       shelf_view_(nullptr),
-      background_animator_(SHELF_BACKGROUND_DEFAULT, wm_shelf_aura_),
+      background_animator_(SHELF_BACKGROUND_DEFAULT, wm_shelf_),
       activating_as_fallback_(false) {
   background_animator_.AddObserver(this);
   background_animator_.AddObserver(delegate_view_);
 
   views::Widget::InitParams params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   params.name = "ShelfWidget";
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.delegate = delegate_view_;
   shelf_container->GetRootWindowController()
       ->ConfigureWidgetInitParamsForContainer(
           this, shelf_container->GetShellWindowId(), &params);
   Init(params);
 
   // The shelf should not take focus when initially shown.
   set_focus_on_creation(false);
   SetContentsView(delegate_view_);
   delegate_view_->SetParentLayer(GetLayer());
 
   shelf_layout_manager_ = new ShelfLayoutManager(this);
   shelf_layout_manager_->AddObserver(this);
   shelf_container->SetLayoutManager(base::WrapUnique(shelf_layout_manager_));
   background_animator_.PaintBackground(
       shelf_layout_manager_->GetShelfBackgroundType(),
       BACKGROUND_CHANGE_IMMEDIATE);
-  wm_shelf_aura_->SetShelfLayoutManager(shelf_layout_manager_);
+  wm_shelf_->SetShelfLayoutManager(shelf_layout_manager_);
 
   // TODO(jamescook): Move ownership to RootWindowController.
-  status_area_widget_ = new StatusAreaWidget(status_container, wm_shelf_aura_);
+  status_area_widget_ = new StatusAreaWidget(status_container, wm_shelf_);
   status_area_widget_->CreateTrayViews();
   if (WmShell::Get()->GetSessionStateDelegate()->IsActiveUserSessionStarted())
     status_area_widget_->Show();
   WmShell::Get()->focus_cycler()->AddWidget(status_area_widget_);
   background_animator_.AddObserver(status_area_widget_);
   status_container->SetLayoutManager(
       base::MakeUnique<StatusAreaLayoutManager>(this));
 
   views::Widget::AddObserver(this);
 }
@@ skipping 60 matching lines @@
     case LoginStatus::KIOSK_APP:
     case LoginStatus::NOT_LOGGED_IN:
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
 ShelfAlignment ShelfWidget::GetAlignment() const {
-  WmShelf* wm_shelf = static_cast<WmShelf*>(wm_shelf_aura_);
-  return wm_shelf->GetAlignment();
+  return wm_shelf_->GetAlignment();
 }
 
 void ShelfWidget::OnShelfAlignmentChanged() {
   status_area_widget_->SetShelfAlignment(GetAlignment());
   delegate_view_->SchedulePaint();
 }
 
 void ShelfWidget::SetDimsShelf(bool dimming) {
   delegate_view_->SetDimmed(dimming);
   // Repaint all children, allowing updates to reflect dimmed state eg:
   // status area background, app list button and overflow button.
   if (shelf_view_)
     shelf_view_->SchedulePaintForAllButtons();
   status_area_widget_->SchedulePaint();
 }
 
 bool ShelfWidget::GetDimsShelf() const {
   return delegate_view_->GetDimmed();
 }
 
 ShelfView* ShelfWidget::CreateShelfView() {
   DCHECK(!shelf_);
   DCHECK(!shelf_view_);
 
   shelf_view_ =
       new ShelfView(WmShell::Get()->shelf_model(),
-                    WmShell::Get()->shelf_delegate(), wm_shelf_aura_, this);
+                    WmShell::Get()->shelf_delegate(), wm_shelf_, this);
   shelf_view_->Init();
   GetContentsView()->AddChildView(shelf_view_);
   return shelf_view_;
 }
 
 void ShelfWidget::PostCreateShelf() {
   SetFocusCycler(WmShell::Get()->focus_cycler());
 
   // Ensure the newly created |shelf_| gets current values.
   background_animator_.Initialize(this);
@@ skipping 19 matching lines @@
   if (focus_cycler)
     focus_cycler->AddWidget(this);
 }
 
 FocusCycler* ShelfWidget::GetFocusCycler() {
   return delegate_view_->focus_cycler();
 }
 
 void ShelfWidget::Shutdown() {
   // Tear down the dimmer before |shelf_layout_manager_|, since the dimmer uses
-  // |shelf_layout_manager_| to get the shelf's WmWindow, via WmShelfAura.
+  // |shelf_layout_manager_| to get the shelf's WmWindow, via WmShelf.
   delegate_view_->SetDimmed(false);
 
   // Shutting down the status area widget may cause some widgets (e.g. bubbles)
   // to close, so uninstall the ShelfLayoutManager event filters first. Don't
   // reset the pointer until later because other widgets (e.g. app list) may
   // access it later in shutdown.
   if (shelf_layout_manager_)
     shelf_layout_manager_->PrepareForShutdown();
 
   if (status_area_widget_) {
@@ skipping 38 matching lines @@
   if (shelf_view_)
     shelf_view_->UpdateShelfItemBackground(alpha);
 }
 
 void ShelfWidget::WillDeleteShelfLayoutManager() {
   shelf_layout_manager_->RemoveObserver(this);
   shelf_layout_manager_ = nullptr;
 }
 
 }  // namespace ash