clang-format all of //ash

ash/common/system/date/date_view.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/common/system/date/date_view.h"
 
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/system/tray/tray_constants.h"
 #include "ash/common/system/tray/tray_utils.h"
 #include "ash/common/wm_shell.h"
@@ skipping 32 matching lines @@
 // Offset used to bring the minutes line closer to the hours line in the
 // vertical clock.
 const int kVerticalClockMinutesTopOffset = -4;
 
 base::string16 FormatDate(const base::Time& time) {
   icu::UnicodeString date_string;
   std::unique_ptr<icu::DateFormat> formatter(
       icu::DateFormat::createDateInstance(icu::DateFormat::kMedium));
   formatter->format(static_cast<UDate>(time.ToDoubleT() * 1000), date_string);
   return base::string16(date_string.getBuffer(),
-                  static_cast<size_t>(date_string.length()));
+                        static_cast<size_t>(date_string.length()));
 }
 
 base::string16 FormatDayOfWeek(const base::Time& time) {
   UErrorCode status = U_ZERO_ERROR;
   std::unique_ptr<icu::DateTimePatternGenerator> generator(
       icu::DateTimePatternGenerator::createInstance(status));
   DCHECK(U_SUCCESS(status));
   const char kBasePattern[] = "EEE";
   icu::UnicodeString generated_pattern =
       generator->getBestPattern(icu::UnicodeString(kBasePattern), status);
   DCHECK(U_SUCCESS(status));
   icu::SimpleDateFormat simple_formatter(generated_pattern, status);
   DCHECK(U_SUCCESS(status));
   icu::UnicodeString date_string;
-  simple_formatter.format(
-      static_cast<UDate>(time.ToDoubleT() * 1000), date_string, status);
+  simple_formatter.format(static_cast<UDate>(time.ToDoubleT() * 1000),
+                          date_string, status);
   DCHECK(U_SUCCESS(status));
-  return base::string16(
-      date_string.getBuffer(), static_cast<size_t>(date_string.length()));
+  return base::string16(date_string.getBuffer(),
+                        static_cast<size_t>(date_string.length()));
 }
 
 views::Label* CreateLabel() {
   views::Label* label = new views::Label;
   label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   label->SetBackgroundColor(SkColorSetARGB(0, 255, 255, 255));
   return label;
 }
 
 }  // namespace
@@ skipping 31 matching lines @@
   // 60 seconds from now.
   int seconds_left = 60 - exploded.second;
   if (seconds_left == 0)
     seconds_left = 60;
 
   // Make sure that the timer fires on the next minute. Without this, if it is
   // called just a teeny bit early, then it will skip the next minute.
   seconds_left += kTimerSlopSeconds;
 
   timer_.Stop();
-  timer_.Start(
-      FROM_HERE, base::TimeDelta::FromSeconds(seconds_left),
-      this, &BaseDateTimeView::UpdateText);
+  timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(seconds_left), this,
+               &BaseDateTimeView::UpdateText);
 }
 
 void BaseDateTimeView::UpdateTextInternal(const base::Time& now) {
   SetAccessibleName(base::TimeFormatTimeOfDayWithHourClockType(
                         now, hour_type_, base::kKeepAmPm) +
                     base::ASCIIToUTF16(", ") +
                     base::TimeFormatFriendlyDate(now));
 
   NotifyAccessibilityEvent(ui::AX_EVENT_TEXT_CHANGED, true);
 }
 
 void BaseDateTimeView::ChildPreferredSizeChanged(views::View* child) {
   PreferredSizeChanged();
 }
 
 void BaseDateTimeView::OnLocaleChanged() {
   UpdateText();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 DateView::DateView() : action_(TrayDate::NONE) {
-  SetLayoutManager(
-      new views::BoxLayout(
-          views::BoxLayout::kVertical, 0, 0, 0));
+  SetLayoutManager(new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0));
   date_label_ = CreateLabel();
   date_label_->SetEnabledColor(kHeaderTextColorNormal);
   UpdateTextInternal(base::Time::Now());
   AddChildView(date_label_);
 }
 
-DateView::~DateView() {
-}
+DateView::~DateView() {}
 
 void DateView::SetAction(TrayDate::DateAction action) {
   if (action == action_)
     return;
   if (IsMouseHovered()) {
-    date_label_->SetEnabledColor(
-        action == TrayDate::NONE ? kHeaderTextColorNormal :
-                                   kHeaderTextColorHover);
+    date_label_->SetEnabledColor(action == TrayDate::NONE
+                                     ? kHeaderTextColorNormal
+                                     : kHeaderTextColorHover);
     SchedulePaint();
   }
   action_ = action;
   SetFocusBehavior(action_ != TrayDate::NONE ? FocusBehavior::ALWAYS
                                              : FocusBehavior::NEVER);
 }
 
 void DateView::UpdateTimeFormat() {
   hour_type_ = WmShell::Get()->system_tray_delegate()->GetHourClockType();
   UpdateText();
 }
 
 base::HourClockType DateView::GetHourTypeForTesting() const {
   return hour_type_;
 }
 
 void DateView::SetActive(bool active) {
   date_label_->SetEnabledColor(active ? kHeaderTextColorHover
                                       : kHeaderTextColorNormal);
   SchedulePaint();
 }
 
 void DateView::UpdateTextInternal(const base::Time& now) {
   BaseDateTimeView::UpdateTextInternal(now);
-  date_label_->SetText(
-      l10n_util::GetStringFUTF16(
-          IDS_ASH_STATUS_TRAY_DATE, FormatDayOfWeek(now), FormatDate(now)));
+  date_label_->SetText(l10n_util::GetStringFUTF16(
+      IDS_ASH_STATUS_TRAY_DATE, FormatDayOfWeek(now), FormatDate(now)));
 }
 
 bool DateView::PerformAction(const ui::Event& event) {
   if (action_ == TrayDate::NONE)
     return false;
   if (action_ == TrayDate::SHOW_DATE_SETTINGS)
     WmShell::Get()->system_tray_delegate()->ShowDateSettings();
   else if (action_ == TrayDate::SET_SYSTEM_TIME)
     WmShell::Get()->system_tray_delegate()->ShowSetTimeDialog();
   return true;
@@ skipping 24 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 TimeView::TimeView(TrayDate::ClockLayout clock_layout) {
   SetupLabels();
   UpdateTextInternal(base::Time::Now());
   UpdateClockLayout(clock_layout);
 }
 
-TimeView::~TimeView() {
-}
+TimeView::~TimeView() {}
 
 void TimeView::UpdateTimeFormat() {
   hour_type_ = WmShell::Get()->system_tray_delegate()->GetHourClockType();
   UpdateText();
 }
 
 base::HourClockType TimeView::GetHourTypeForTesting() const {
   return hour_type_;
 }
 
@@ skipping 11 matching lines @@
       now, hour_type_, base::kDropAmPm);
   horizontal_label_->SetText(current_time);
   horizontal_label_->SetTooltipText(base::TimeFormatFriendlyDate(now));
 
   // Calculate vertical clock layout labels.
   size_t colon_pos = current_time.find(base::ASCIIToUTF16(":"));
   base::string16 hour = current_time.substr(0, colon_pos);
   base::string16 minute = current_time.substr(colon_pos + 1);
 
   // Sometimes pad single-digit hours with a zero for aesthetic reasons.
-  if (hour.length() == 1 &&
-      hour_type_ == base::k24HourClock &&
+  if (hour.length() == 1 && hour_type_ == base::k24HourClock &&
       !base::i18n::IsRTL())
     hour = base::ASCIIToUTF16("0") + hour;
 
   vertical_label_hours_->SetText(hour);
   vertical_label_minutes_->SetText(minute);
   Layout();
 }
 
 bool TimeView::PerformAction(const ui::Event& event) {
   return false;
@@ skipping 27 matching lines @@
     layout->StartRow(0, kColumnId);
     layout->AddView(vertical_label_minutes_.get());
     layout->AddPaddingRow(0, kTrayLabelItemVerticalPaddingVerticalAlignment);
   }
   Layout();
 }
 
 void TimeView::SetBorderFromLayout(TrayDate::ClockLayout clock_layout) {
   if (clock_layout == TrayDate::HORIZONTAL_CLOCK)
     SetBorder(views::Border::CreateEmptyBorder(
-        0,
-        kTrayLabelItemHorizontalPaddingBottomAlignment,
-        0,
+        0, kTrayLabelItemHorizontalPaddingBottomAlignment, 0,
         kTrayLabelItemHorizontalPaddingBottomAlignment));
   else
     SetBorder(views::Border::NullBorder());
 }
 
 void TimeView::SetupLabels() {
   horizontal_label_.reset(CreateLabel());
   SetupLabel(horizontal_label_.get());
   vertical_label_hours_.reset(CreateLabel());
   SetupLabel(vertical_label_hours_.get());
   vertical_label_minutes_.reset(CreateLabel());
   SetupLabel(vertical_label_minutes_.get());
   vertical_label_minutes_->SetEnabledColor(kVerticalClockMinuteColor);
   // Pull the minutes up closer to the hours by using a negative top border.
   vertical_label_minutes_->SetBorder(views::Border::CreateEmptyBorder(
       kVerticalClockMinutesTopOffset, 0, 0, 0));
 }
 
 void TimeView::SetupLabel(views::Label* label) {
   label->set_owned_by_client();
   SetupLabelForTray(label);
   label->SetElideBehavior(gfx::NO_ELIDE);
 }
 
 }  // namespace tray
 }  // namespace ash