Eliminate ash::internal namespace

ash/system/tray/system_tray.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/system/tray/system_tray.h"
 
 #include "ash/ash_switches.h"
 #include "ash/metrics/user_metrics_recorder.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shell.h"
@@ skipping 55 matching lines @@
 #include "media/audio/win/core_audio_util_win.h"
 #endif
 
 using views::TrayBubbleView;
 
 namespace ash {
 
 // The minimum width of the system tray menu width.
 const int kMinimumSystemTrayMenuWidth = 300;
 
-namespace internal {
-
 // Class to initialize and manage the SystemTrayBubble and TrayBubbleWrapper
 // instances for a bubble.
 
 class SystemBubbleWrapper {
  public:
   // Takes ownership of |bubble|.
-  explicit SystemBubbleWrapper(internal::SystemTrayBubble* bubble)
-      : bubble_(bubble),
-        is_persistent_(false) {
-  }
+  explicit SystemBubbleWrapper(SystemTrayBubble* bubble)
+      : bubble_(bubble), is_persistent_(false) {}
 
   // Initializes the bubble view and creates |bubble_wrapper_|.
   void InitView(TrayBackgroundView* tray,
                 views::View* anchor,
                 TrayBubbleView::InitParams* init_params,
                 bool is_persistent) {
     DCHECK(anchor);
     user::LoginStatus login_status =
         Shell::GetInstance()->system_tray_delegate()->GetUserLoginStatus();
     bubble_->InitView(anchor, login_status, init_params);
-    bubble_wrapper_.reset(
-        new internal::TrayBubbleWrapper(tray, bubble_->bubble_view()));
+    bubble_wrapper_.reset(new TrayBubbleWrapper(tray, bubble_->bubble_view()));
     if (ash::switches::UseAlternateShelfLayout()) {
       // The system bubble should not have an arrow.
       bubble_->bubble_view()->SetArrowPaintType(
           views::BubbleBorder::PAINT_NONE);
     }
     is_persistent_ = is_persistent;
 
     // If ChromeVox is enabled, focus the default item if no item is focused.
     if (Shell::GetInstance()->accessibility_delegate()->
         IsSpokenFeedbackEnabled()) {
       bubble_->FocusDefaultIfNeeded();
     }
   }
 
   // Convenience accessors:
   SystemTrayBubble* bubble() const { return bubble_.get(); }
   SystemTrayBubble::BubbleType bubble_type() const {
     return bubble_->bubble_type();
   }
   TrayBubbleView* bubble_view() const { return bubble_->bubble_view(); }
   bool is_persistent() const { return is_persistent_; }
 
  private:
-  scoped_ptr<internal::SystemTrayBubble> bubble_;
-  scoped_ptr<internal::TrayBubbleWrapper> bubble_wrapper_;
+  scoped_ptr<SystemTrayBubble> bubble_;
+  scoped_ptr<TrayBubbleWrapper> bubble_wrapper_;
   bool is_persistent_;
 
   DISALLOW_COPY_AND_ASSIGN(SystemBubbleWrapper);
 };
 
-}  // namespace internal
 
 // SystemTray
 
-using internal::SystemTrayBubble;
-
-SystemTray::SystemTray(internal::StatusAreaWidget* status_area_widget)
-    : internal::TrayBackgroundView(status_area_widget),
+SystemTray::SystemTray(StatusAreaWidget* status_area_widget)
+    : TrayBackgroundView(status_area_widget),
       items_(),
       default_bubble_height_(0),
       hide_notifications_(false),
       full_system_tray_menu_(false),
       tray_accessibility_(NULL),
       tray_date_(NULL) {
   SetContentsBackground();
 }
 
 SystemTray::~SystemTray() {
   // Destroy any child views that might have back pointers before ~View().
   system_bubble_.reset();
   notification_bubble_.reset();
   for (std::vector<SystemTrayItem*>::iterator it = items_.begin();
        it != items_.end();
        ++it) {
     (*it)->DestroyTrayView();
   }
 }
 
 void SystemTray::InitializeTrayItems(SystemTrayDelegate* delegate) {
-  internal::TrayBackgroundView::Initialize();
+  TrayBackgroundView::Initialize();
   CreateItems(delegate);
 }
 
 void SystemTray::CreateItems(SystemTrayDelegate* delegate) {
 #if defined(OS_CHROMEOS)
-  AddTrayItem(new internal::TraySessionLengthLimit(this));
+  AddTrayItem(new TraySessionLengthLimit(this));
 #endif
 #if !defined(OS_WIN)
   // Create user items for each possible user.
   ash::Shell* shell = ash::Shell::GetInstance();
   int maximum_user_profiles =
           shell->session_state_delegate()->GetMaximumNumberOfLoggedInUsers();
   for (int i = 0; i < maximum_user_profiles; i++)
-    AddTrayItem(new internal::TrayUser(this, i));
+    AddTrayItem(new TrayUser(this, i));
 
   if (maximum_user_profiles > 1) {
     // Add a special double line separator between users and the rest of the
     // menu if more then one user is logged in.
-    AddTrayItem(new internal::TrayUserSeparator(this));
+    AddTrayItem(new TrayUserSeparator(this));
   }
 #endif
 
-  tray_accessibility_ = new internal::TrayAccessibility(this);
-  tray_date_ = new internal::TrayDate(this);
+  tray_accessibility_ = new TrayAccessibility(this);
+  tray_date_ = new TrayDate(this);
 
 #if defined(OS_CHROMEOS)
-  AddTrayItem(new internal::TrayEnterprise(this));
-  AddTrayItem(new internal::TrayLocallyManagedUser(this));
-  AddTrayItem(new internal::TrayIME(this));
+  AddTrayItem(new TrayEnterprise(this));
+  AddTrayItem(new TrayLocallyManagedUser(this));
+  AddTrayItem(new TrayIME(this));
   AddTrayItem(tray_accessibility_);
-  AddTrayItem(new internal::TrayTracing(this));
-  AddTrayItem(
-      new internal::TrayPower(this, message_center::MessageCenter::Get()));
-  AddTrayItem(new internal::TrayNetwork(this));
-  AddTrayItem(new internal::TrayVPN(this));
-  AddTrayItem(new internal::TraySms(this));
-  AddTrayItem(new internal::TrayBluetooth(this));
-  AddTrayItem(new internal::TrayDrive(this));
-  AddTrayItem(new internal::TrayDisplay(this));
-  AddTrayItem(new internal::ScreenCaptureTrayItem(this));
-  AddTrayItem(new internal::ScreenShareTrayItem(this));
-  AddTrayItem(new internal::TrayAudioChromeOs(this));
-  AddTrayItem(new internal::TrayBrightness(this));
-  AddTrayItem(new internal::TrayCapsLock(this));
-  AddTrayItem(new internal::TraySettings(this));
-  AddTrayItem(new internal::TrayUpdate(this));
+  AddTrayItem(new TrayTracing(this));
+  AddTrayItem(new TrayPower(this, message_center::MessageCenter::Get()));
+  AddTrayItem(new TrayNetwork(this));
+  AddTrayItem(new TrayVPN(this));
+  AddTrayItem(new TraySms(this));
+  AddTrayItem(new TrayBluetooth(this));
+  AddTrayItem(new TrayDrive(this));
+  AddTrayItem(new TrayDisplay(this));
+  AddTrayItem(new ScreenCaptureTrayItem(this));
+  AddTrayItem(new ScreenShareTrayItem(this));
+  AddTrayItem(new TrayAudioChromeOs(this));
+  AddTrayItem(new TrayBrightness(this));
+  AddTrayItem(new TrayCapsLock(this));
+  AddTrayItem(new TraySettings(this));
+  AddTrayItem(new TrayUpdate(this));
   AddTrayItem(tray_date_);
 #elif defined(OS_WIN)
   AddTrayItem(tray_accessibility_);
   if (media::CoreAudioUtil::IsSupported())
-    AddTrayItem(new internal::TrayAudioWin(this));
-  AddTrayItem(new internal::TrayUpdate(this));
+    AddTrayItem(new TrayAudioWin(this));
+  AddTrayItem(new TrayUpdate(this));
   AddTrayItem(tray_date_);
 #elif defined(OS_LINUX)
-  AddTrayItem(new internal::TrayIME(this));
+  AddTrayItem(new TrayIME(this));
   AddTrayItem(tray_accessibility_);
-  AddTrayItem(new internal::TrayBluetooth(this));
-  AddTrayItem(new internal::TrayDrive(this));
-  AddTrayItem(new internal::TrayUpdate(this));
+  AddTrayItem(new TrayBluetooth(this));
+  AddTrayItem(new TrayDrive(this));
+  AddTrayItem(new TrayUpdate(this));
   AddTrayItem(tray_date_);
 #endif
 
   SetVisible(ash::Shell::GetInstance()->system_tray_delegate()->
       GetTrayVisibilityOnStartup());
 }
 
 void SystemTray::AddTrayItem(SystemTrayItem* item) {
   items_.push_back(item);
 
@@ skipping 112 matching lines @@
 }
 
 bool SystemTray::HasSystemBubble() const {
   return system_bubble_.get() != NULL;
 }
 
 bool SystemTray::HasNotificationBubble() const {
   return notification_bubble_.get() != NULL;
 }
 
-internal::SystemTrayBubble* SystemTray::GetSystemBubble() {
+SystemTrayBubble* SystemTray::GetSystemBubble() {
   if (!system_bubble_)
     return NULL;
   return system_bubble_->bubble();
 }
 
 bool SystemTray::IsAnyBubbleVisible() const {
   return ((system_bubble_.get() &&
            system_bubble_->bubble()->IsVisible()) ||
           (notification_bubble_.get() &&
            notification_bubble_->bubble()->IsVisible()));
@@ skipping 132 matching lines @@
     }
     init_params.arrow_offset = arrow_offset;
     if (bubble_type == SystemTrayBubble::BUBBLE_TYPE_DEFAULT)
       init_params.close_on_deactivate = !persistent;
     // For Volume and Brightness we don't want to show an arrow when
     // they are shown in a bubble by themselves.
     init_params.arrow_paint_type = views::BubbleBorder::PAINT_NORMAL;
     if (items.size() == 1 && items[0]->ShouldHideArrow())
       init_params.arrow_paint_type = views::BubbleBorder::PAINT_TRANSPARENT;
     SystemTrayBubble* bubble = new SystemTrayBubble(this, items, bubble_type);
-    system_bubble_.reset(new internal::SystemBubbleWrapper(bubble));
+    system_bubble_.reset(new SystemBubbleWrapper(bubble));
     system_bubble_->InitView(this, tray_container(), &init_params, persistent);
   }
   // Save height of default view for creating detailed views directly.
   if (!detailed)
     default_bubble_height_ = system_bubble_->bubble_view()->height();
 
   if (detailed && items.size() > 0)
     detailed_item_ = items[0];
   else
     detailed_item_ = NULL;
@@ skipping 36 matching lines @@
     anchor_type = TrayBubbleView::ANCHOR_TYPE_TRAY;
   }
   TrayBubbleView::InitParams init_params(anchor_type,
                                          GetAnchorAlignment(),
                                          kTrayPopupMinWidth,
                                          kTrayPopupMaxWidth);
   init_params.first_item_has_no_margin =
       ash::switches::UseAlternateShelfLayout();
   init_params.arrow_color = kBackgroundColor;
   init_params.arrow_offset = GetTrayXOffset(notification_items_[0]);
-  notification_bubble_.reset(
-      new internal::SystemBubbleWrapper(notification_bubble));
+  notification_bubble_.reset(new SystemBubbleWrapper(notification_bubble));
   notification_bubble_->InitView(this, anchor, &init_params, false);
 
   if (notification_bubble->bubble_view()->child_count() == 0) {
     // It is possible that none of the items generated actual notifications.
     DestroyNotificationBubble();
     return;
   }
   if (hide_notifications_)
     notification_bubble->SetVisible(false);
   else
@@ skipping 18 matching lines @@
       height = std::max(
           0, bubble_view->GetBoundsInScreen().bottom() - work_area.y());
     }
   }
   status_area_widget()->web_notification_tray()->SetSystemTrayHeight(height);
 }
 
 void SystemTray::SetShelfAlignment(ShelfAlignment alignment) {
   if (alignment == shelf_alignment())
     return;
-  internal::TrayBackgroundView::SetShelfAlignment(alignment);
+  TrayBackgroundView::SetShelfAlignment(alignment);
   UpdateAfterShelfAlignmentChange(alignment);
   // Destroy any existing bubble so that it is rebuilt correctly.
   CloseSystemBubbleAndDeactivateSystemTray();
   // Rebuild any notification bubble.
   if (notification_bubble_) {
     notification_bubble_.reset();
     UpdateNotificationBubble();
   }
 }
 
@@ skipping 67 matching lines @@
 void SystemTray::HideBubble(const TrayBubbleView* bubble_view) {
   HideBubbleWithView(bubble_view);
 }
 
 views::View* SystemTray::GetTrayItemViewForTest(SystemTrayItem* item) {
   std::map<SystemTrayItem*, views::View*>::iterator it =
       tray_item_map_.find(item);
   return it == tray_item_map_.end() ? NULL : it->second;
 }
 
-internal::TrayDate* SystemTray::GetTrayDateForTesting() const {
-  return tray_date_;
-}
+TrayDate* SystemTray::GetTrayDateForTesting() const { return tray_date_; }
 
 bool SystemTray::PerformAction(const ui::Event& event) {
   // If we're already showing the default view, hide it; otherwise, show it
   // (and hide any popup that's currently shown).
   if (HasSystemBubbleType(SystemTrayBubble::BUBBLE_TYPE_DEFAULT)) {
     system_bubble_->bubble()->Close();
   } else {
     int arrow_offset = TrayBubbleView::InitParams::kArrowDefaultOffset;
     if (event.IsMouseEvent() || event.type() == ui::ET_GESTURE_TAP) {
       const ui::LocatedEvent& located_event =
@@ skipping 14 matching lines @@
   system_bubble_.reset();
   // When closing a system bubble with the alternate shelf layout, we need to
   // turn off the active tinting of the shelf.
   if (full_system_tray_menu_) {
     SetDrawBackgroundAsActive(false);
     full_system_tray_menu_ = false;
   }
 }
 
 }  // namespace ash