Eliminate ash::internal namespace

ash/shelf/shelf_widget.cc

 // Copyright (c) 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/ash_switches.h"
 #include "ash/focus_cycler.h"
 #include "ash/root_window_controller.h"
 #include "ash/session_state_delegate.h"
@@ skipping 34 matching lines @@
 // Alpha to paint dimming image with.
 const int kDimAlpha = 128;
 
 // The time to dim and un-dim.
 const int kTimeToDimMs = 3000;  // Slow in dimming.
 const int kTimeToUnDimMs = 200;  // Fast in activating.
 
 // Class used to slightly dim shelf items when maximized and visible.
 class DimmerView : public views::View,
                    public views::WidgetDelegate,
-                   ash::internal::BackgroundAnimatorDelegate {
+                   ash::BackgroundAnimatorDelegate {
  public:
   // If |disable_dimming_animations_for_test| is set, all alpha animations will
   // be performed instantly.
   DimmerView(ash::ShelfWidget* shelf_widget,
              bool disable_dimming_animations_for_test);
   virtual ~DimmerView();
 
   // Called by |DimmerEventFilter| when the mouse |hovered| state changes.
   void SetHovered(bool hovered);
 
   // Force the dimmer to be undimmed.
   void ForceUndimming(bool force);
 
   // views::WidgetDelegate overrides:
   virtual views::Widget* GetWidget() OVERRIDE {
     return View::GetWidget();
   }
   virtual const views::Widget* GetWidget() const OVERRIDE {
     return View::GetWidget();
   }
 
-  // ash::internal::BackgroundAnimatorDelegate overrides:
+  // ash::BackgroundAnimatorDelegate overrides:
   virtual void UpdateBackground(int alpha) OVERRIDE {
     alpha_ = alpha;
     SchedulePaint();
   }
 
   // views::View overrides:
   virtual void OnPaintBackground(gfx::Canvas* canvas) OVERRIDE;
 
   // A function to test the current alpha used.
   int get_dimming_alpha_for_test() { return alpha_; }
@@ skipping 31 matching lines @@
   // True if the event filter claims that we should not be dimmed.
   bool is_hovered_;
 
   // True if someone forces us not to be dimmed (e.g. a menu is open).
   bool force_hovered_;
 
   // True if animations should be suppressed for a test.
   bool disable_dimming_animations_for_test_;
 
   // The animator for the background transitions.
-  ash::internal::BackgroundAnimator background_animator_;
+  ash::BackgroundAnimator background_animator_;
 
   // Notification of entering / exiting of the shelf area by mouse.
   scoped_ptr<DimmerEventFilter> event_filter_;
 
   DISALLOW_COPY_AND_ASSIGN(DimmerView);
 };
 
 DimmerView::DimmerView(ash::ShelfWidget* shelf_widget,
                        bool disable_dimming_animations_for_test)
     : shelf_(shelf_widget),
@@ skipping 87 matching lines @@
   bool touch_inside = false;
   if (event->type() != ui::ET_TOUCH_RELEASED &&
       event->type() != ui::ET_TOUCH_CANCELLED)
     touch_inside = owner_->GetBoundsInScreen().Contains(event->root_location());
 
   if (mouse_inside_ || touch_inside_ != mouse_inside_ || touch_inside)
     owner_->SetHovered(mouse_inside_ || touch_inside);
   touch_inside_ = touch_inside;
 }
 
-using ash::internal::ShelfLayoutManager;
+using ash::ShelfLayoutManager;
 
 // ShelfWindowTargeter makes it easier to resize windows with the mouse when the
 // window-edge slightly overlaps with the shelf edge. The targeter also makes it
 // easier to drag the shelf out with touch while it is hidden.
 class ShelfWindowTargeter : public wm::EasyResizeWindowTargeter,
                             public ash::ShelfLayoutManagerObserver {
  public:
   ShelfWindowTargeter(aura::Window* container,
                       ShelfLayoutManager* shelf)
       : wm::EasyResizeWindowTargeter(container, gfx::Insets(), gfx::Insets()),
@@ skipping 58 matching lines @@
 };
 
 }  // namespace
 
 namespace ash {
 
 // The contents view of the Shelf. This view contains ShelfView and
 // sizes it to the width of the shelf minus the size of the status area.
 class ShelfWidget::DelegateView : public views::WidgetDelegate,
                                   public views::AccessiblePaneView,
-                                  public internal::BackgroundAnimatorDelegate,
+                                  public BackgroundAnimatorDelegate,
                                   public aura::WindowObserver {
  public:
   explicit DelegateView(ShelfWidget* shelf);
   virtual ~DelegateView();
 
-  void set_focus_cycler(internal::FocusCycler* focus_cycler) {
+  void set_focus_cycler(FocusCycler* focus_cycler) {
     focus_cycler_ = focus_cycler;
   }
-  internal::FocusCycler* focus_cycler() {
-    return focus_cycler_;
-  }
+  FocusCycler* focus_cycler() { return focus_cycler_; }
 
   ui::Layer* opaque_background() { return &opaque_background_; }
 
   // Set if the shelf area is dimmed (eg when a window is maximized).
   void SetDimmed(bool dimmed);
   bool GetDimmed() const;
 
   void SetParentLayer(ui::Layer* layer);
 
   // views::View overrides:
@@ skipping 38 matching lines @@
 
   // Disable dimming animations for running tests. This needs to be called
   // prior to the creation of of the |dimmer_|.
   void disable_dimming_animations_for_test() {
     disable_dimming_animations_for_test_ = true;
   }
 
  private:
   ShelfWidget* shelf_;
   scoped_ptr<views::Widget> dimmer_;
-  internal::FocusCycler* focus_cycler_;
+  FocusCycler* focus_cycler_;
   int alpha_;
   ui::Layer opaque_background_;
 
   // The view which does the dimming.
   DimmerView* dimmer_view_;
 
   // True if dimming animations should be turned off.
   bool disable_dimming_animations_for_test_;
 
   DISALLOW_COPY_AND_ASSIGN(DelegateView);
@@ skipping 197 matching lines @@
   return gfx::Rect();
 }
 
 void ShelfWidget::DelegateView::UpdateBackground(int alpha) {
   alpha_ = alpha;
   SchedulePaint();
 }
 
 ShelfWidget::ShelfWidget(aura::Window* shelf_container,
                          aura::Window* status_container,
-                         internal::WorkspaceController* workspace_controller)
+                         WorkspaceController* workspace_controller)
     : delegate_view_(new DelegateView(this)),
       background_animator_(delegate_view_, 0, kShelfBackgroundAlpha),
       activating_as_fallback_(false),
       window_container_(shelf_container) {
   views::Widget::InitParams params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.parent = shelf_container;
   params.delegate = delegate_view_;
   Init(params);
 
   // The shelf should not take focus when initially shown.
   set_focus_on_creation(false);
   SetContentsView(delegate_view_);
   delegate_view_->SetParentLayer(GetLayer());
 
-  status_area_widget_ = new internal::StatusAreaWidget(status_container);
+  status_area_widget_ = new StatusAreaWidget(status_container);
   status_area_widget_->CreateTrayViews();
   if (Shell::GetInstance()->session_state_delegate()->
           IsActiveUserSessionStarted()) {
     status_area_widget_->Show();
   }
   Shell::GetInstance()->focus_cycler()->AddWidget(status_area_widget_);
 
-  shelf_layout_manager_ = new internal::ShelfLayoutManager(this);
+  shelf_layout_manager_ = new ShelfLayoutManager(this);
   shelf_layout_manager_->AddObserver(this);
   shelf_container->SetLayoutManager(shelf_layout_manager_);
   shelf_layout_manager_->set_workspace_controller(workspace_controller);
   workspace_controller->SetShelf(shelf_layout_manager_);
 
-  status_container->SetLayoutManager(
-      new internal::StatusAreaLayoutManager(this));
+  status_container->SetLayoutManager(new StatusAreaLayoutManager(this));
 
   shelf_container->SetEventTargeter(scoped_ptr<ui::EventTargeter>(new
       ShelfWindowTargeter(shelf_container, shelf_layout_manager_)));
   status_container->SetEventTargeter(scoped_ptr<ui::EventTargeter>(new
       ShelfWindowTargeter(status_container, shelf_layout_manager_)));
 
   views::Widget::AddObserver(this);
 }
 
 ShelfWidget::~ShelfWidget() {
@@ skipping 88 matching lines @@
   // This needs to be called before shelf_model().
   ShelfDelegate* shelf_delegate = shell->GetShelfDelegate();
   if (!shelf_delegate)
     return;  // Not ready to create Shelf.
 
   shelf_.reset(
       new Shelf(shell->shelf_model(), shell->GetShelfDelegate(), this));
   SetFocusCycler(shell->focus_cycler());
 
   // Inform the root window controller.
-  internal::RootWindowController::ForWindow(window_container_)
-      ->OnShelfCreated();
+  RootWindowController::ForWindow(window_container_)->OnShelfCreated();
 
   shelf_->SetVisible(
       shell->session_state_delegate()->IsActiveUserSessionStarted());
   shelf_layout_manager_->LayoutShelf();
   Show();
 }
 
 bool ShelfWidget::IsShelfVisible() const {
   return shelf_.get() && shelf_->IsVisible();
 }
 
 void ShelfWidget::SetShelfVisibility(bool visible) {
   if (shelf_)
     shelf_->SetVisible(visible);
 }
 
-void ShelfWidget::SetFocusCycler(internal::FocusCycler* focus_cycler) {
+void ShelfWidget::SetFocusCycler(FocusCycler* focus_cycler) {
   delegate_view_->set_focus_cycler(focus_cycler);
   if (focus_cycler)
     focus_cycler->AddWidget(this);
 }
 
-internal::FocusCycler* ShelfWidget::GetFocusCycler() {
+FocusCycler* ShelfWidget::GetFocusCycler() {
   return delegate_view_->focus_cycler();
 }
 
 void ShelfWidget::ShutdownStatusAreaWidget() {
   if (status_area_widget_)
     status_area_widget_->Shutdown();
   status_area_widget_ = NULL;
 }
 
 void ShelfWidget::ForceUndimming(bool force) {
@@ skipping 25 matching lines @@
   DCHECK(delegate_view_);
   return delegate_view_->disable_dimming_animations_for_test();
 }
 
 void ShelfWidget::WillDeleteShelf() {
   shelf_layout_manager_->RemoveObserver(this);
   shelf_layout_manager_ = NULL;
 }
 
 }  // namespace ash