Rename Launcher to Shelf.

ash/wm/dock/docked_window_layout_manager.cc

 // Copyright (c) 2013 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/wm/dock/docked_window_layout_manager.h"
 
 #include "ash/ash_switches.h"
-#include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
+#include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
@@ skipping 71 matching lines @@
     // background retire background_animator_ at all. It would be simpler.
     // See also ShelfWidget::SetPaintsBackground.
     background_animator_.SetPaintsBackground(
         background_type != SHELF_BACKGROUND_DEFAULT,
         change_type);
     SchedulePaintInRect(gfx::Rect(GetWindowBoundsInScreen().size()));
   }
 
   // views::Widget:
   virtual void OnNativeWidgetPaint(gfx::Canvas* canvas) OVERRIDE {
-    const gfx::ImageSkia& launcher_background(
+    const gfx::ImageSkia& shelf_background(
         alignment_ == DOCKED_ALIGNMENT_LEFT ?
-            launcher_background_left_ : launcher_background_right_);
+            shelf_background_left_ : shelf_background_right_);
     gfx::Rect rect = gfx::Rect(GetWindowBoundsInScreen().size());
     SkPaint paint;
     paint.setAlpha(alpha_);
+    canvas->DrawImageInt(shelf_background,
+                         0,
+                         0,
+                         shelf_background.width(),
+                         shelf_background.height(),
+                         alignment_ == DOCKED_ALIGNMENT_LEFT
+                             ? rect.width() - shelf_background.width()
+                             : 0,
+                         0,
+                         shelf_background.width(),
+                         rect.height(),
+                         false,
+                         paint);
     canvas->DrawImageInt(
-        launcher_background,
-        0, 0, launcher_background.width(), launcher_background.height(),
-        alignment_ == DOCKED_ALIGNMENT_LEFT ?
-            rect.width() - launcher_background.width() : 0, 0,
-        launcher_background.width(), rect.height(),
-        false,
-        paint);
-    canvas->DrawImageInt(
-        launcher_background,
-        alignment_ == DOCKED_ALIGNMENT_LEFT ?
-            0 : launcher_background.width() - 1, 0,
-        1, launcher_background.height(),
-        alignment_ == DOCKED_ALIGNMENT_LEFT ?
-            0 : launcher_background.width(), 0,
-        rect.width() - launcher_background.width(), rect.height(),
+        shelf_background,
+        alignment_ == DOCKED_ALIGNMENT_LEFT ? 0 : shelf_background.width() - 1,
+        0,
+        1,
+        shelf_background.height(),
+        alignment_ == DOCKED_ALIGNMENT_LEFT ? 0 : shelf_background.width(),
+        0,
+        rect.width() - shelf_background.width(),
+        rect.height(),
         false,
         paint);
   }
 
   // BackgroundAnimatorDelegate:
   virtual void UpdateBackground(int alpha) OVERRIDE {
     alpha_ = alpha;
     SchedulePaintInRect(gfx::Rect(GetWindowBoundsInScreen().size()));
   }
 
@@ skipping 10 matching lines @@
     set_focus_on_creation(false);
     Init(params);
     GetNativeWindow()->SetProperty(internal::kStayInSameRootWindowKey, true);
     opaque_background_.SetColor(SK_ColorBLACK);
     opaque_background_.SetBounds(gfx::Rect(GetWindowBoundsInScreen().size()));
     opaque_background_.SetOpacity(0.0f);
     GetNativeWindow()->layer()->Add(&opaque_background_);
     Hide();
 
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-    gfx::ImageSkia launcher_background =
+    gfx::ImageSkia shelf_background =
         *rb.GetImageSkiaNamed(IDR_AURA_LAUNCHER_BACKGROUND);
-    launcher_background_left_ = gfx::ImageSkiaOperations::CreateRotatedImage(
-        launcher_background, SkBitmapOperations::ROTATION_90_CW);
-    launcher_background_right_ = gfx::ImageSkiaOperations::CreateRotatedImage(
-        launcher_background, SkBitmapOperations::ROTATION_270_CW);
+    shelf_background_left_ = gfx::ImageSkiaOperations::CreateRotatedImage(
+        shelf_background, SkBitmapOperations::ROTATION_90_CW);
+    shelf_background_right_ = gfx::ImageSkiaOperations::CreateRotatedImage(
+        shelf_background, SkBitmapOperations::ROTATION_270_CW);
   }
 
   DockedAlignment alignment_;
 
   // The animator for the background transitions.
   internal::BackgroundAnimator background_animator_;
 
   // The alpha to use for drawing image assets covering the docked background.
   int alpha_;
 
   // Solid black background that can be made fully opaque.
   ui::Layer opaque_background_;
 
   // Backgrounds created from shelf background by 90 or 270 degree rotation.
-  gfx::ImageSkia launcher_background_left_;
-  gfx::ImageSkia launcher_background_right_;
+  gfx::ImageSkia shelf_background_left_;
+  gfx::ImageSkia shelf_background_right_;
 
   DISALLOW_COPY_AND_ASSIGN(DockedBackgroundWidget);
 };
 
 namespace {
 
 // Returns true if a window is a popup or a transient child.
 bool IsPopupOrTransient(const aura::Window* window) {
   return (window->type() == aura::client::WINDOW_TYPE_POPUP ||
           window->transient_parent());
@@ skipping 128 matching lines @@
   }
 
  private:
   aura::Window* dragged_window_;
   float delta_;
 };
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
-// A class that observes launcher shelf for bounds changes.
+// A class that observes shelf for bounds changes.
 class DockedWindowLayoutManager::ShelfWindowObserver : public WindowObserver {
  public:
   explicit ShelfWindowObserver(
       DockedWindowLayoutManager* docked_layout_manager)
       : docked_layout_manager_(docked_layout_manager) {
-    DCHECK(docked_layout_manager_->launcher()->shelf_widget());
-    docked_layout_manager_->launcher()->shelf_widget()->GetNativeView()
+    DCHECK(docked_layout_manager_->shelf()->shelf_widget());
+    docked_layout_manager_->shelf()->shelf_widget()->GetNativeView()
         ->AddObserver(this);
   }
 
   virtual ~ShelfWindowObserver() {
-    if (docked_layout_manager_->launcher() &&
-        docked_layout_manager_->launcher()->shelf_widget())
-      docked_layout_manager_->launcher()->shelf_widget()->GetNativeView()
+    if (docked_layout_manager_->shelf() &&
+        docked_layout_manager_->shelf()->shelf_widget())
+      docked_layout_manager_->shelf()->shelf_widget()->GetNativeView()
           ->RemoveObserver(this);
   }
 
   // aura::WindowObserver:
   virtual void OnWindowBoundsChanged(aura::Window* window,
                                      const gfx::Rect& old_bounds,
                                      const gfx::Rect& new_bounds) OVERRIDE {
     shelf_bounds_in_screen_ = ScreenAsh::ConvertRectToScreen(
         window->parent(), new_bounds);
     docked_layout_manager_->OnShelfBoundsChanged();
@@ skipping 12 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // DockedWindowLayoutManager public implementation:
 DockedWindowLayoutManager::DockedWindowLayoutManager(
     aura::Window* dock_container, WorkspaceController* workspace_controller)
     : dock_container_(dock_container),
       in_layout_(false),
       dragged_window_(NULL),
       is_dragged_window_docked_(false),
       is_dragged_from_dock_(false),
-      launcher_(NULL),
+      shelf_(NULL),
       workspace_controller_(workspace_controller),
       in_fullscreen_(workspace_controller_->GetWindowState() ==
           WORKSPACE_WINDOW_STATE_FULL_SCREEN),
       docked_width_(0),
       alignment_(DOCKED_ALIGNMENT_NONE),
       last_active_window_(NULL),
       last_action_time_(base::Time::Now()),
       background_widget_(new DockedBackgroundWidget(dock_container_)) {
   DCHECK(dock_container);
   aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
       AddObserver(this);
   Shell::GetInstance()->AddShellObserver(this);
 }
 
 DockedWindowLayoutManager::~DockedWindowLayoutManager() {
   Shutdown();
 }
 
 void DockedWindowLayoutManager::Shutdown() {
-  if (launcher_ && launcher_->shelf_widget()) {
-    ShelfLayoutManager* shelf_layout_manager = ShelfLayoutManager::ForLauncher(
-        launcher_->shelf_widget()->GetNativeWindow());
+  if (shelf_ && shelf_->shelf_widget()) {
+    ShelfLayoutManager* shelf_layout_manager = ShelfLayoutManager::ForShelf(
+        shelf_->shelf_widget()->GetNativeWindow());
     shelf_layout_manager->RemoveObserver(this);
     shelf_observer_.reset();
   }
-  launcher_ = NULL;
+  shelf_ = NULL;
   for (size_t i = 0; i < dock_container_->children().size(); ++i) {
     aura::Window* child = dock_container_->children()[i];
     child->RemoveObserver(this);
     wm::GetWindowState(child)->RemoveObserver(this);
   }
   aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
       RemoveObserver(this);
   Shell::GetInstance()->RemoveShellObserver(this);
 }
 
@@ skipping 56 matching lines @@
     // count limit so do it here.
     MaybeMinimizeChildrenExcept(dragged_window_);
   }
   dragged_window_ = NULL;
   dragged_bounds_ = gfx::Rect();
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
   RecordUmaAction(action, source);
 }
 
-void DockedWindowLayoutManager::SetLauncher(ash::Launcher* launcher) {
-  DCHECK(!launcher_);
-  launcher_ = launcher;
-  if (launcher_->shelf_widget()) {
-    ShelfLayoutManager* shelf_layout_manager = ShelfLayoutManager::ForLauncher(
-        launcher_->shelf_widget()->GetNativeWindow());
+void DockedWindowLayoutManager::SetShelf(Shelf* shelf) {
+  DCHECK(!shelf_);
+  shelf_ = shelf;
+  if (shelf_->shelf_widget()) {
+    ShelfLayoutManager* shelf_layout_manager = ShelfLayoutManager::ForShelf(
+        shelf_->shelf_widget()->GetNativeWindow());
     shelf_layout_manager->AddObserver(this);
     shelf_observer_.reset(new ShelfWindowObserver(this));
   }
 }
 
 DockedAlignment DockedWindowLayoutManager::GetAlignmentOfWindow(
     const aura::Window* window) const {
   const gfx::Rect& bounds(window->GetBoundsInScreen());
 
   // Test overlap with an existing docked area first.
@@ skipping 56 matching lines @@
   if (GetWindowHeightCloseTo(window, work_area.height() - 2 * kMinDockGap) >
       work_area.height() - 2 * kMinDockGap) {
     return false;
   }
   // Cannot dock on the other size from an existing dock.
   const DockedAlignment alignment = CalculateAlignment();
   if ((edge == SNAP_LEFT && alignment == DOCKED_ALIGNMENT_RIGHT) ||
       (edge == SNAP_RIGHT && alignment == DOCKED_ALIGNMENT_LEFT)) {
     return false;
   }
-  // Do not allow docking on the same side as launcher shelf.
+  // Do not allow docking on the same side as shelf.
   ShelfAlignment shelf_alignment = SHELF_ALIGNMENT_BOTTOM;
-  if (launcher_)
-    shelf_alignment = launcher_->alignment();
+  if (shelf_)
+    shelf_alignment = shelf_->alignment();
   if ((edge == SNAP_LEFT && shelf_alignment == SHELF_ALIGNMENT_LEFT) ||
       (edge == SNAP_RIGHT && shelf_alignment == SHELF_ALIGNMENT_RIGHT)) {
     return false;
   }
   return true;
 }
 
 void DockedWindowLayoutManager::OnShelfBoundsChanged() {
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::DISPLAY_INSETS_CHANGED);
@@ skipping 60 matching lines @@
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
 }
 
 void DockedWindowLayoutManager::SetChildBounds(
     aura::Window* child,
     const gfx::Rect& requested_bounds) {
   // Whenever one of our windows is moved or resized enforce layout.
   SetChildBoundsDirect(child, requested_bounds);
   if (IsPopupOrTransient(child))
     return;
-  ShelfLayoutManager* shelf_layout = internal::ShelfLayoutManager::ForLauncher(
+  ShelfLayoutManager* shelf_layout = internal::ShelfLayoutManager::ForShelf(
       dock_container_);
   if (shelf_layout)
     shelf_layout->UpdateVisibilityState();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DockedWindowLayoutManager, ash::ShellObserver implementation:
 
 void DockedWindowLayoutManager::OnDisplayWorkAreaInsetsChanged() {
   Relayout();
@@ skipping 31 matching lines @@
   }
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
 }
 
 void DockedWindowLayoutManager::OnShelfAlignmentChanged(
     aura::Window* root_window) {
   if (dock_container_->GetRootWindow() != root_window)
     return;
 
-  if (!launcher_ || !launcher_->shelf_widget())
+  if (!shelf_ || !shelf_->shelf_widget())
     return;
 
   if (alignment_ == DOCKED_ALIGNMENT_NONE)
     return;
 
-  // Do not allow launcher and dock on the same side. Switch side that
+  // Do not allow shelf and dock on the same side. Switch side that
   // the dock is attached to and move all dock windows to that new side.
-  ShelfAlignment shelf_alignment = launcher_->shelf_widget()->GetAlignment();
+  ShelfAlignment shelf_alignment = shelf_->shelf_widget()->GetAlignment();
   if (alignment_ == DOCKED_ALIGNMENT_LEFT &&
       shelf_alignment == SHELF_ALIGNMENT_LEFT) {
     alignment_ = DOCKED_ALIGNMENT_RIGHT;
   } else if (alignment_ == DOCKED_ALIGNMENT_RIGHT &&
              shelf_alignment == SHELF_ALIGNMENT_RIGHT) {
     alignment_ = DOCKED_ALIGNMENT_LEFT;
   }
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::SHELF_ALIGNMENT_CHANGED);
 }
@@ skipping 521 matching lines @@
 void DockedWindowLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& keyboard_bounds) {
   // This bounds change will have caused a change to the Shelf which does not
   // propagate automatically to this class, so manually recalculate bounds.
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::KEYBOARD_BOUNDS_CHANGING);
 }
 
 }  // namespace internal
 }  // namespace ash