clang-format all of //ash

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/common/ash_switches.h"
 #include "ash/common/login_status.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/wm_shelf.h"
@@ skipping 78 matching lines @@
   void InitView(TrayBackgroundView* tray,
                 views::View* anchor,
                 TrayBubbleView::InitParams* init_params,
                 bool is_persistent) {
     DCHECK(anchor);
     LoginStatus login_status =
         WmShell::Get()->system_tray_delegate()->GetUserLoginStatus();
     bubble_->InitView(anchor, login_status, init_params);
     bubble_wrapper_.reset(new TrayBubbleWrapper(tray, bubble_->bubble_view()));
     // The system bubble should not have an arrow.
-    bubble_->bubble_view()->SetArrowPaintType(
-        views::BubbleBorder::PAINT_NONE);
+    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 and
     // there isn't a delayed close.
     if (Shell::GetInstance()
             ->accessibility_delegate()
             ->IsSpokenFeedbackEnabled() &&
         !is_persistent) {
       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:
   std::unique_ptr<SystemTrayBubble> bubble_;
   std::unique_ptr<TrayBubbleWrapper> bubble_wrapper_;
   bool is_persistent_;
 
   DISALLOW_COPY_AND_ASSIGN(SystemBubbleWrapper);
 };
 
-
 // SystemTray
 
 SystemTray::SystemTray(StatusAreaWidget* status_area_widget)
     : TrayBackgroundView(status_area_widget->wm_shelf()),
       status_area_widget_(status_area_widget),
       items_(),
       detailed_item_(nullptr),
       default_bubble_height_(0),
       hide_notifications_(false),
       full_system_tray_menu_(false),
       tray_accessibility_(nullptr),
       tray_cast_(nullptr),
       tray_date_(nullptr),
       tray_update_(nullptr),
       screen_capture_tray_item_(nullptr),
       screen_share_tray_item_(nullptr) {
   DCHECK(status_area_widget_);
   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 != items_.end(); ++it) {
     (*it)->DestroyTrayView();
   }
 }
 
 void SystemTray::InitializeTrayItems(SystemTrayDelegate* delegate) {
   TrayBackgroundView::Initialize();
   CreateItems(delegate);
 }
 
 void SystemTray::CreateItems(SystemTrayDelegate* delegate) {
@@ skipping 69 matching lines @@
 void SystemTray::RemoveTrayItem(SystemTrayItem* item) {
   NOTIMPLEMENTED();
 }
 
 const std::vector<SystemTrayItem*>& SystemTray::GetTrayItems() const {
   return items_.get();
 }
 
 void SystemTray::ShowDefaultView(BubbleCreationType creation_type) {
   ShowDefaultViewWithOffset(
-      creation_type,
-      TrayBubbleView::InitParams::kArrowDefaultOffset,
-      false);
+      creation_type, TrayBubbleView::InitParams::kArrowDefaultOffset, false);
 }
 
 void SystemTray::ShowPersistentDefaultView() {
-  ShowItems(items_.get(),
-            false,
-            false,
-            BUBBLE_CREATE_NEW,
-            TrayBubbleView::InitParams::kArrowDefaultOffset,
-            true);
+  ShowItems(items_.get(), false, false, BUBBLE_CREATE_NEW,
+            TrayBubbleView::InitParams::kArrowDefaultOffset, true);
 }
 
 void SystemTray::ShowDetailedView(SystemTrayItem* item,
                                   int close_delay,
                                   bool activate,
                                   BubbleCreationType creation_type) {
   std::vector<SystemTrayItem*> items;
   // The detailed view with timeout means a UI to show the current system state,
   // like the audio level or brightness. Such UI should behave as persistent and
   // keep its own logic for the appearance.
-  bool persistent = (
-      !activate && close_delay > 0 && creation_type == BUBBLE_CREATE_NEW);
+  bool persistent =
+      (!activate && close_delay > 0 && creation_type == BUBBLE_CREATE_NEW);
   items.push_back(item);
-  ShowItems(
-      items, true, activate, creation_type, GetTrayXOffset(item), persistent);
+  ShowItems(items, true, activate, creation_type, GetTrayXOffset(item),
+            persistent);
   if (system_bubble_)
     system_bubble_->bubble()->StartAutoCloseTimer(close_delay);
 }
 
 void SystemTray::SetDetailedViewCloseDelay(int close_delay) {
   if (HasSystemBubbleType(SystemTrayBubble::BUBBLE_TYPE_DETAILED))
     system_bubble_->bubble()->StartAutoCloseTimer(close_delay);
 }
 
 void SystemTray::HideDetailedView(SystemTrayItem* item) {
   if (item != detailed_item_)
     return;
   DestroySystemBubble();
   UpdateNotificationBubble();
 }
 
 void SystemTray::ShowNotificationView(SystemTrayItem* item) {
-  if (std::find(notification_items_.begin(), notification_items_.end(), item)
-      != notification_items_.end())
+  if (std::find(notification_items_.begin(), notification_items_.end(), item) !=
+      notification_items_.end())
     return;
   notification_items_.push_back(item);
   UpdateNotificationBubble();
 }
 
 void SystemTray::HideNotificationView(SystemTrayItem* item) {
   std::vector<SystemTrayItem*>::iterator found_iter =
       std::find(notification_items_.begin(), notification_items_.end(), item);
   if (found_iter == notification_items_.end())
     return;
@@ skipping 42 matching lines @@
   return notification_bubble_.get() != NULL;
 }
 
 SystemTrayBubble* SystemTray::GetSystemBubble() {
   if (!system_bubble_)
     return NULL;
   return system_bubble_->bubble();
 }
 
 bool SystemTray::IsAnyBubbleVisible() const {
-  return ((system_bubble_.get() &&
-           system_bubble_->bubble()->IsVisible()) ||
+  return ((system_bubble_.get() && system_bubble_->bubble()->IsVisible()) ||
           (notification_bubble_.get() &&
            notification_bubble_->bubble()->IsVisible()));
 }
 
 bool SystemTray::IsMouseInNotificationBubble() const {
   if (!notification_bubble_)
     return false;
   return notification_bubble_->bubble_view()->GetBoundsInScreen().Contains(
       display::Screen::GetScreen()->GetCursorScreenPoint());
 }
@@ skipping 35 matching lines @@
     UpdateWebNotifications();
   }
 }
 
 base::string16 SystemTray::GetAccessibleNameForTray() {
   base::string16 time = GetAccessibleTimeString(base::Time::Now());
   base::string16 battery = base::ASCIIToUTF16("");
 #if defined(OS_CHROMEOS)
   battery = PowerStatus::Get()->GetAccessibleNameString(false);
 #endif
-  return l10n_util::GetStringFUTF16(
-      IDS_ASH_STATUS_TRAY_ACCESSIBLE_DESCRIPTION, time, battery);
+  return l10n_util::GetStringFUTF16(IDS_ASH_STATUS_TRAY_ACCESSIBLE_DESCRIPTION,
+                                    time, battery);
 }
 
 int SystemTray::GetTrayXOffset(SystemTrayItem* item) const {
   // Don't attempt to align the arrow if the shelf is on the left or right.
   if (!IsHorizontalAlignment(shelf_alignment()))
     return TrayBubbleView::InitParams::kArrowDefaultOffset;
 
   std::map<SystemTrayItem*, views::View*>::const_iterator it =
       tray_item_map_.find(item);
   if (it == tray_item_map_.end())
@@ skipping 25 matching lines @@
                            BubbleCreationType creation_type,
                            int arrow_offset,
                            bool persistent) {
   // No system tray bubbles in kiosk mode.
   if (WmShell::Get()->system_tray_delegate()->GetUserLoginStatus() ==
       LoginStatus::KIOSK_APP) {
     return;
   }
 
   // Destroy any existing bubble and create a new one.
-  SystemTrayBubble::BubbleType bubble_type = detailed ?
-      SystemTrayBubble::BUBBLE_TYPE_DETAILED :
-      SystemTrayBubble::BUBBLE_TYPE_DEFAULT;
+  SystemTrayBubble::BubbleType bubble_type =
+      detailed ? SystemTrayBubble::BUBBLE_TYPE_DETAILED
+               : SystemTrayBubble::BUBBLE_TYPE_DEFAULT;
 
   // Destroy the notification bubble here so that it doesn't get rebuilt
   // while we add items to the main bubble_ (e.g. in HideNotificationView).
   notification_bubble_.reset();
   if (system_bubble_.get() && creation_type == BUBBLE_USE_EXISTING) {
     system_bubble_->bubble()->UpdateView(items, bubble_type);
     // If ChromeVox is enabled, focus the default item if no item is focused.
-    if (Shell::GetInstance()->accessibility_delegate()->
-        IsSpokenFeedbackEnabled()) {
+    if (Shell::GetInstance()
+            ->accessibility_delegate()
+            ->IsSpokenFeedbackEnabled()) {
       system_bubble_->bubble()->FocusDefaultIfNeeded();
     }
   } else {
     // Cleanup the existing bubble before showing a new one. Otherwise, it's
     // possible to confuse the new system bubble with the old one during
     // destruction, leading to subtle errors/crashes such as crbug.com/545166.
     DestroySystemBubble();
 
     // Remember if the menu is a single property (like e.g. volume) or the
     // full tray menu. Note that in case of the |BUBBLE_USE_EXISTING| case
     // above, |full_system_tray_menu_| does not get changed since the fact that
     // the menu is full (or not) doesn't change even if a "single property"
     // (like network) replaces most of the menu.
     full_system_tray_menu_ = items.size() > 1;
     // The menu width is fixed, and it is a per language setting.
     int menu_width = std::max(
         kMinimumSystemTrayMenuWidth,
         WmShell::Get()->system_tray_delegate()->GetSystemTrayMenuWidth());
 
     TrayBubbleView::InitParams init_params(TrayBubbleView::ANCHOR_TYPE_TRAY,
-                                           GetAnchorAlignment(),
-                                           menu_width,
+                                           GetAnchorAlignment(), menu_width,
                                            kTrayPopupMaxWidth);
     init_params.can_activate = can_activate;
     init_params.first_item_has_no_margin = true;
     if (detailed) {
       // This is the case where a volume control or brightness control bubble
       // is created.
       init_params.max_height = default_bubble_height_;
       init_params.arrow_color = kBackgroundColor;
     } else {
       init_params.arrow_color = kHeaderBackgroundColor;
@@ skipping 45 matching lines @@
   notification_bubble_.reset();
   SystemTrayBubble* notification_bubble;
   notification_bubble = new SystemTrayBubble(
       this, notification_items_, SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION);
   views::View* anchor;
   TrayBubbleView::AnchorType anchor_type;
   // Tray items might want to show notifications while we are creating and
   // initializing the |system_bubble_| - but it might not be fully initialized
   // when coming here - this would produce a crashed like crbug.com/247416.
   // As such we check the existence of the widget here.
-  if (system_bubble_.get() &&
-      system_bubble_->bubble_view() &&
+  if (system_bubble_.get() && system_bubble_->bubble_view() &&
       system_bubble_->bubble_view()->GetWidget()) {
     anchor = system_bubble_->bubble_view();
     anchor_type = TrayBubbleView::ANCHOR_TYPE_BUBBLE;
   } else {
     anchor = tray_container();
     anchor_type = TrayBubbleView::ANCHOR_TYPE_TRAY;
   }
-  TrayBubbleView::InitParams init_params(anchor_type,
-                                         GetAnchorAlignment(),
+  TrayBubbleView::InitParams init_params(anchor_type, GetAnchorAlignment(),
                                          kTrayPopupMinWidth,
                                          kTrayPopupMaxWidth);
   init_params.first_item_has_no_margin = true;
   init_params.arrow_color = kBackgroundColor;
   init_params.arrow_offset = GetTrayXOffset(notification_items_[0]);
   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.
@@ skipping 22 matching lines @@
     height =
         std::max(0, work_area.height() - bubble_view->GetBoundsInScreen().y());
   }
   status_area_widget_->web_notification_tray()->SetSystemTrayHeight(height);
 }
 
 base::string16 SystemTray::GetAccessibleTimeString(
     const base::Time& now) const {
   base::HourClockType hour_type =
       WmShell::Get()->system_tray_delegate()->GetHourClockType();
-  return base::TimeFormatTimeOfDayWithHourClockType(
-      now, hour_type, base::kKeepAmPm);
+  return base::TimeFormatTimeOfDayWithHourClockType(now, hour_type,
+                                                    base::kKeepAmPm);
 }
 
 void SystemTray::SetShelfAlignment(ShelfAlignment alignment) {
   if (alignment == shelf_alignment())
     return;
   TrayBackgroundView::SetShelfAlignment(alignment);
   UpdateAfterShelfAlignmentChange(alignment);
   // Destroy any existing bubble so that it is rebuilt correctly.
   CloseSystemBubbleAndDeactivateSystemTray();
   // Rebuild any notification bubble.
@@ skipping 83 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;
 }
 
-TrayCast* SystemTray::GetTrayCastForTesting() const { return tray_cast_; }
+TrayCast* SystemTray::GetTrayCastForTesting() const {
+  return tray_cast_;
+}
 
-TrayDate* SystemTray::GetTrayDateForTesting() const { return tray_date_; }
+TrayDate* SystemTray::GetTrayDateForTesting() const {
+  return tray_date_;
+}
 
 TrayUpdate* SystemTray::GetTrayUpdateForTesting() const {
   return tray_update_;
 }
 
 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();
@@ skipping 42 matching lines @@
           .work_area()
           .height();
   if (work_area_height > 0) {
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Ash.SystemMenu.PercentageOfWorkAreaHeightCoveredByMenu",
         100 * bubble_view->height() / work_area_height, 1, 300, 100);
   }
 }
 
 }  // namespace ash