Cleanup: Remove std::string("") usage.

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 <cmath>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 61 matching lines @@
   }
 };
 
 struct DisplayInfoSortFunctor {
   bool operator()(const DisplayInfo& a, const DisplayInfo& b) {
     return a.id() < b.id();
   }
 };
 
 struct ResolutionMatcher {
-  ResolutionMatcher(const gfx::Size& size) : size(size) {}
+  explicit ResolutionMatcher(const gfx::Size& size) : size(size) {}
   bool operator()(const Resolution& resolution) {
     return resolution.size == size;
   }
   gfx::Size size;
 };
 
 struct ScaleComparator {
-  ScaleComparator(float s) : scale(s) {}
+  explicit ScaleComparator(float s) : scale(s) {}
 
   bool operator()(float s) const {
     const float kEpsilon = 0.0001f;
     return std::abs(scale - s) < kEpsilon;
   }
   float scale;
 };
 
 gfx::Display& GetInvalidDisplay() {
   static gfx::Display* invalid_display = new gfx::Display();
@@ skipping 366 matching lines @@
     Shell::GetInstance()->output_configurator()->ScheduleConfigureOutputs();
 #endif
 }
 
 void DisplayManager::RegisterDisplayProperty(
     int64 display_id,
     gfx::Display::Rotation rotation,
     float ui_scale,
     const gfx::Insets* overscan_insets,
     const gfx::Size& resolution_in_pixels) {
-  if (display_info_.find(display_id) == display_info_.end()) {
-    display_info_[display_id] =
-        DisplayInfo(display_id, std::string(""), false);
-  }
+  if (display_info_.find(display_id) == display_info_.end())
+    display_info_[display_id] = DisplayInfo(display_id, std::string(), false);
 
   display_info_[display_id].set_rotation(rotation);
   // Just in case the preference file was corrupted.
   if (0.5f <= ui_scale && ui_scale <= 2.0f)
     display_info_[display_id].set_configured_ui_scale(ui_scale);
   if (overscan_insets)
     display_info_[display_id].SetOverscanInsets(*overscan_insets);
   if (!resolution_in_pixels.IsEmpty())
     resolutions_[display_id] = resolution_in_pixels;
 }
@@ skipping 207 matching lines @@
           current_display_info.bounds_in_native() !=
           new_display_info.bounds_in_native();
 
       if (force_bounds_changed_ ||
           host_window_bounds_changed ||
           (current_display.device_scale_factor() !=
            new_display.device_scale_factor()) ||
           (current_display_info.size_in_pixel() !=
            new_display.GetSizeInPixel()) ||
           (current_display.rotation() != new_display.rotation())) {
-
         changed_display_indices.push_back(new_displays.size());
       }
 
       new_display.UpdateWorkAreaFromInsets(current_display.GetWorkAreaInsets());
       new_displays.push_back(new_display);
       ++curr_iter;
       ++new_info_iter;
     } else if (curr_iter->id() < new_info_iter->id()) {
       // more displays in current list between ids, which means it is deleted.
       removed_displays.push_back(*curr_iter);
@@ skipping 249 matching lines @@
 
 void DisplayManager::AddMirrorDisplayInfoIfAny(
     std::vector<DisplayInfo>* display_info_list) {
   if (software_mirroring_enabled() && IsMirrored())
     display_info_list->push_back(GetDisplayInfo(mirrored_display_id_));
 }
 
 void DisplayManager::InsertAndUpdateDisplayInfo(const DisplayInfo& new_info) {
   std::map<int64, DisplayInfo>::iterator info =
       display_info_.find(new_info.id());
-  if (info != display_info_.end())
+  if (info != display_info_.end()) {
     info->second.Copy(new_info);
-  else {
+  } else {
     display_info_[new_info.id()] = new_info;
     display_info_[new_info.id()].set_native(false);
   }
   display_info_[new_info.id()].UpdateDisplaySize();
 }
 
 gfx::Display DisplayManager::CreateDisplayFromDisplayInfoById(int64 id) {
   DCHECK(display_info_.find(id) != display_info_.end());
   const DisplayInfo& display_info = display_info_[id];
 
@@ skipping 17 matching lines @@
     DisplayList* displays,
     size_t* updated_index) const {
   if (displays->size() != 2U)
     return false;
 
   int64 id_at_zero = displays->at(0).id();
   DisplayIdPair pair =
       (id_at_zero == first_display_id_ ||
        id_at_zero == gfx::Display::InternalDisplayId()) ?
       std::make_pair(id_at_zero, displays->at(1).id()) :
-      std::make_pair(displays->at(1).id(), id_at_zero) ;
+      std::make_pair(displays->at(1).id(), id_at_zero);
   DisplayLayout layout =
       layout_store_->ComputeDisplayLayoutForDisplayIdPair(pair);
 
   // Ignore if a user has a old format (should be extremely rare)
   // and this will be replaced with DCHECK.
   if (layout.primary_id != gfx::Display::kInvalidDisplayID) {
     size_t primary_index, secondary_index;
     if (displays->at(0).id() == layout.primary_id) {
       primary_index = 0;
       secondary_index = 1;
@@ skipping 56 matching lines @@
       break;
   }
   gfx::Insets insets = secondary_display->GetWorkAreaInsets();
   secondary_display->set_bounds(
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
 }  // namespace internal
 }  // namespace ash