clang-format all of //ash

ash/display/display_manager.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/display/display_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <map>
@@ skipping 467 matching lines @@
   return true;
 }
 
 bool DisplayManager::IsDisplayUIScalingEnabled() const {
   return GetDisplayIdForUIScaling() != display::Display::kInvalidDisplayID;
 }
 
 gfx::Insets DisplayManager::GetOverscanInsets(int64_t display_id) const {
   std::map<int64_t, DisplayInfo>::const_iterator it =
       display_info_.find(display_id);
-  return (it != display_info_.end()) ?
-      it->second.overscan_insets_in_dip() : gfx::Insets();
+  return (it != display_info_.end()) ? it->second.overscan_insets_in_dip()
+                                     : gfx::Insets();
 }
 
 void DisplayManager::SetColorCalibrationProfile(
     int64_t display_id,
     ui::ColorCalibrationProfile profile) {
 #if defined(OS_CHROMEOS)
   if (!display_info_[display_id].IsColorProfileAvailable(profile))
     return;
 
   if (delegate_)
     delegate_->PreDisplayConfigurationChange(false);
   // Just sets color profile if it's not running on ChromeOS (like tests).
   if (!base::SysInfo::IsRunningOnChromeOS() ||
       Shell::GetInstance()->display_configurator()->SetColorCalibrationProfile(
           display_id, profile)) {
     display_info_[display_id].SetColorProfile(profile);
-    UMA_HISTOGRAM_ENUMERATION(
-        "ChromeOS.Display.ColorProfile", profile, ui::NUM_COLOR_PROFILES);
+    UMA_HISTOGRAM_ENUMERATION("ChromeOS.Display.ColorProfile", profile,
+                              ui::NUM_COLOR_PROFILES);
   }
   if (delegate_)
     delegate_->PostDisplayConfigurationChange();
 #endif
 }
 
 void DisplayManager::OnNativeDisplaysChanged(
     const std::vector<DisplayInfo>& updated_displays) {
   if (updated_displays.empty()) {
     VLOG(1) << "OnNativeDisplaysChanged(0): # of current displays="
@@ skipping 30 matching lines @@
             << ") [0]=" << updated_displays[0].ToString()
             << ", [1]=" << updated_displays[1].ToString();
   }
 
   bool internal_display_connected = false;
   num_connected_displays_ = updated_displays.size();
   mirroring_display_id_ = display::Display::kInvalidDisplayID;
   software_mirroring_display_list_.clear();
   DisplayInfoList new_display_info_list;
   for (DisplayInfoList::const_iterator iter = updated_displays.begin();
-       iter != updated_displays.end();
-       ++iter) {
+       iter != updated_displays.end(); ++iter) {
     if (!internal_display_connected)
       internal_display_connected =
           display::Display::IsInternalDisplayId(iter->id());
     // Mirrored monitors have the same origins.
     gfx::Point origin = iter->bounds_in_native().origin();
     if (origins.find(origin) != origins.end()) {
       InsertAndUpdateDisplayInfo(*iter);
       mirroring_display_id_ = iter->id();
     } else {
       origins.insert(origin);
@@ skipping 62 matching lines @@
   DisplayInfoList display_info_list;
   for (const auto& display : active_display_list_)
     display_info_list.push_back(GetDisplayInfo(display.id()));
   AddMirrorDisplayInfoIfAny(&display_info_list);
   UpdateDisplaysWith(display_info_list);
 }
 
 void DisplayManager::UpdateDisplaysWith(
     const std::vector<DisplayInfo>& updated_display_info_list) {
 #if defined(OS_WIN)
-  DCHECK_EQ(1u, updated_display_info_list.size()) <<
-      ": Multiple display test does not work on Windows bots. Please "
-      "skip (don't disable) the test using SupportsMultipleDisplays()";
+  DCHECK_EQ(1u, updated_display_info_list.size())
+      << ": Multiple display test does not work on Windows bots. Please "
+         "skip (don't disable) the test using SupportsMultipleDisplays()";
 #endif
 
   DisplayInfoList new_display_info_list = updated_display_info_list;
   std::sort(active_display_list_.begin(), active_display_list_.end(),
             DisplaySortFunctor());
-  std::sort(new_display_info_list.begin(),
-            new_display_info_list.end(),
+  std::sort(new_display_info_list.begin(), new_display_info_list.end(),
             DisplayInfoSortFunctor());
 
   if (new_display_info_list.size() > 1) {
     display::DisplayIdList list = GenerateDisplayIdList(
         new_display_info_list.begin(), new_display_info_list.end(),
         [](const DisplayInfo& info) { return info.id(); });
     const display::DisplayLayout& layout =
         layout_store_->GetRegisteredDisplayLayout(list);
     current_default_multi_display_mode_ =
         (layout.default_unified && unified_desktop_enabled_) ? UNIFIED
@@ skipping 42 matching lines @@
           CreateDisplayFromDisplayInfoById(new_info_iter->id());
       const DisplayInfo& new_display_info = GetDisplayInfo(new_display.id());
 
       uint32_t metrics = display::DisplayObserver::DISPLAY_METRIC_NONE;
 
       // At that point the new Display objects we have are not entirely updated,
       // they are missing the translation related to the Display disposition in
       // the layout.
       // Using display.bounds() and display.work_area() would fail most of the
       // time.
-      if (force_bounds_changed_ ||
-          (current_display_info.bounds_in_native() !=
-           new_display_info.bounds_in_native()) ||
+      if (force_bounds_changed_ || (current_display_info.bounds_in_native() !=
+                                    new_display_info.bounds_in_native()) ||
           (current_display_info.GetOverscanInsetsInPixel() !=
            new_display_info.GetOverscanInsetsInPixel()) ||
           current_display.size() != new_display.size()) {
         metrics |= display::DisplayObserver::DISPLAY_METRIC_BOUNDS |
                    display::DisplayObserver::DISPLAY_METRIC_WORK_AREA;
       }
 
       if (current_display.device_scale_factor() !=
           new_display.device_scale_factor()) {
         metrics |= display::DisplayObserver::DISPLAY_METRIC_DEVICE_SCALE_FACTOR;
@@ skipping 67 matching lines @@
 
   for (size_t index : added_display_indices)
     screen_->NotifyDisplayAdded(active_display_list_[index]);
 
   active_display_list_.resize(active_display_list_size);
 
   bool notify_primary_change =
       delegate_ ? old_primary.id() != screen_->GetPrimaryDisplay().id() : false;
 
   for (std::map<size_t, uint32_t>::iterator iter = display_changes.begin();
-       iter != display_changes.end();
-       ++iter) {
+       iter != display_changes.end(); ++iter) {
     uint32_t metrics = iter->second;
     const display::Display& updated_display = active_display_list_[iter->first];
 
     if (notify_primary_change &&
         updated_display.id() == screen_->GetPrimaryDisplay().id()) {
       metrics |= display::DisplayObserver::DISPLAY_METRIC_PRIMARY;
       notify_primary_change = false;
     }
     screen_->NotifyMetricsChanged(updated_display, metrics);
   }
@@ skipping 448 matching lines @@
   DCHECK(display_info_.find(id) != display_info_.end()) << "id=" << id;
   const DisplayInfo& display_info = display_info_[id];
 
   display::Display new_display(display_info.id());
   gfx::Rect bounds_in_native(display_info.size_in_pixel());
   float device_scale_factor = display_info.GetEffectiveDeviceScaleFactor();
 
   // Simply set the origin to (0,0).  The primary display's origin is
   // always (0,0) and the bounds of non-primary display(s) will be updated
   // in |UpdateNonPrimaryDisplayBoundsForLayout| called in |UpdateDisplay|.
-  new_display.SetScaleAndBounds(
-      device_scale_factor, gfx::Rect(bounds_in_native.size()));
+  new_display.SetScaleAndBounds(device_scale_factor,
+                                gfx::Rect(bounds_in_native.size()));
   new_display.set_rotation(display_info.GetActiveRotation());
   new_display.set_touch_support(display_info.touch_support());
   new_display.set_maximum_cursor_size(display_info.maximum_cursor_size());
   return new_display;
 }
 
 display::Display DisplayManager::CreateMirroringDisplayFromDisplayInfoById(
     int64_t id,
     const gfx::Point& origin,
     float scale) {
@@ skipping 52 matching lines @@
   layout.ApplyToDisplayList(display_list, updated_ids,
                             kMinimumOverlapForInvalidOffset);
 }
 
 void DisplayManager::RunPendingTasksForTest() {
   if (!software_mirroring_display_list_.empty())
     base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace ash