Remove ash_util namespace

chrome/browser/extensions/display_info_provider_chromeos.cc

 // Copyright 2014 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 "chrome/browser/extensions/display_info_provider_chromeos.h"
 
 #include <stdint.h>
 
 #include "ash/display/display_configuration_controller.h"
 #include "ash/display/resolution_notification_controller.h"
@@ skipping 427 matching lines @@
     "Another touch calibration is already active.";
 
 DisplayInfoProviderChromeOS::DisplayInfoProviderChromeOS() {}
 
 DisplayInfoProviderChromeOS::~DisplayInfoProviderChromeOS() {}
 
 bool DisplayInfoProviderChromeOS::SetInfo(
     const std::string& display_id_str,
     const system_display::DisplayProperties& info,
     std::string* error) {
-  if (ash_util::IsRunningInMash()) {
+  if (IsRunningInMash()) {
     // TODO(crbug.com/682402): Mash support.
     NOTIMPLEMENTED();
     *error = "Not implemented for mash.";
     return false;
   }
   display::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   ash::DisplayConfigurationController* display_configuration_controller =
       ash::Shell::GetInstance()->display_configuration_controller();
 
@@ skipping 53 matching lines @@
                          new_bounds_origin.y() - target.bounds().y());
     UpdateDisplayLayout(primary.bounds(), primary.id(), target_bounds,
                         target.id());
   }
 
   return true;
 }
 
 bool DisplayInfoProviderChromeOS::SetDisplayLayout(
     const DisplayLayoutList& layouts) {
-  if (ash_util::IsRunningInMash()) {
+  if (IsRunningInMash()) {
     // TODO(crbug.com/682402): Mash support.
     NOTIMPLEMENTED();
     return false;
   }
   display::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   display::DisplayLayoutBuilder builder(
       display_manager->GetCurrentResolvedDisplayLayout());
 
   bool have_root = false;
@@ skipping 26 matching lines @@
   }
   ash::Shell::GetInstance()
       ->display_configuration_controller()
       ->SetDisplayLayout(std::move(layout), true /* user_action */);
   return true;
 }
 
 void DisplayInfoProviderChromeOS::UpdateDisplayUnitInfoForPlatform(
     const display::Display& display,
     system_display::DisplayUnitInfo* unit) {
-  if (ash_util::IsRunningInMash()) {
+  if (IsRunningInMash()) {
     // TODO(crbug.com/682402): Mash support.
     NOTIMPLEMENTED();
     return;
   }
   display::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   unit->name = display_manager->GetDisplayNameForId(display.id());
   if (display_manager->IsInMirrorMode()) {
     unit->mirroring_source_id =
         base::Int64ToString(display_manager->mirroring_display_id());
@@ skipping 15 matching lines @@
   unit->overscan.bottom = overscan_insets.bottom();
 
   for (const scoped_refptr<display::ManagedDisplayMode>& display_mode :
        display_info.display_modes()) {
     unit->modes.push_back(
         GetDisplayMode(display_manager, display_info, display_mode));
   }
 }
 
 void DisplayInfoProviderChromeOS::EnableUnifiedDesktop(bool enable) {
-  if (ash_util::IsRunningInMash()) {
+  if (IsRunningInMash()) {
     // TODO(crbug.com/682402): Mash support.
     NOTIMPLEMENTED();
     return;
   }
   ash::Shell::GetInstance()->display_manager()->SetUnifiedDesktopEnabled(
       enable);
 }
 
 DisplayInfoProvider::DisplayUnitInfoList
 DisplayInfoProviderChromeOS::GetAllDisplaysInfo() {
-  if (ash_util::IsRunningInMash()) {
+  if (IsRunningInMash()) {
     // TODO(crbug.com/682402): Mash support.
     NOTIMPLEMENTED();
     return DisplayInfoProvider::DisplayUnitInfoList();
   }
   display::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   if (!display_manager->IsInUnifiedMode())
     return DisplayInfoProvider::GetAllDisplaysInfo();
 
   std::vector<display::Display> displays =
       display_manager->software_mirroring_display_list();
   CHECK_GT(displays.size(), 0u);
 
   // Use first display as primary.
   int64_t primary_id = displays[0].id();
   DisplayUnitInfoList all_displays;
   for (const display::Display& display : displays) {
     system_display::DisplayUnitInfo unit =
         CreateDisplayUnitInfo(display, primary_id);
     UpdateDisplayUnitInfoForPlatform(display, &unit);
     all_displays.push_back(std::move(unit));
   }
   return all_displays;
 }
 
 DisplayInfoProvider::DisplayLayoutList
 DisplayInfoProviderChromeOS::GetDisplayLayout() {
-  if (ash_util::IsRunningInMash()) {
+  if (IsRunningInMash()) {
     // TODO(crbug.com/682402): Mash support.
     NOTIMPLEMENTED();
     return DisplayInfoProvider::DisplayLayoutList();
   }
   display::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
 
   if (display_manager->num_connected_displays() < 2)
     return DisplayInfoProvider::DisplayLayoutList();
 
@@ skipping 12 matching lines @@
     display_layout.parent_id = base::Int64ToString(placement.parent_display_id);
     display_layout.position = GetLayoutPosition(placement.position);
     display_layout.offset = placement.offset;
     result.push_back(std::move(display_layout));
   }
   return result;
 }
 
 bool DisplayInfoProviderChromeOS::OverscanCalibrationStart(
     const std::string& id) {
-  if (ash_util::IsRunningInMash()) {
+  if (IsRunningInMash()) {
     // TODO(crbug.com/682402): Mash support.
     NOTIMPLEMENTED();
     return false;
   }
   VLOG(1) << "OverscanCalibrationStart: " << id;
   const display::Display display = GetDisplay(id);
   if (display.id() == display::kInvalidDisplayId)
     return false;
   auto insets =
       ash::Shell::GetInstance()->window_tree_host_manager()->GetOverscanInsets(
@@ skipping 33 matching lines @@
   if (!calibrator)
     return false;
   calibrator->Commit();
   overscan_calibrators_[id].reset();
   return true;
 }
 
 bool DisplayInfoProviderChromeOS::ShowNativeTouchCalibration(
     const std::string& id, std::string* error,
     const DisplayInfoProvider::TouchCalibrationCallback& callback) {
-  if (ash_util::IsRunningInMash()) {
+  if (IsRunningInMash()) {
     // TODO(crbug.com/682402): Mash support.
     NOTIMPLEMENTED();
     return false;
   }
   VLOG(1) << "StartNativeTouchCalibration: " << id;
 
   // If a custom calibration is already running, then throw an error.
   if (custom_touch_calibration_active_) {
     *error = kCustomTouchCalibrationInProgressError;
     return false;
   }
 
   const display::Display display = GetDisplay(id);
   if (!ValidateParamsForTouchCalibration(id, display, GetTouchCalibrator(),
                                          error)) {
     return false;
   }
 
   GetTouchCalibrator()->StartCalibration(display, callback);
   return true;
 }
 
 bool DisplayInfoProviderChromeOS::StartCustomTouchCalibration(
     const std::string& id,
     std::string* error) {
-  if (ash_util::IsRunningInMash()) {
+  if (IsRunningInMash()) {
     // TODO(crbug.com/682402): Mash support.
     NOTIMPLEMENTED();
     return false;
   }
   VLOG(1) << "StartCustomTouchCalibration: " << id;
   const display::Display display = GetDisplay(id);
   if (!ValidateParamsForTouchCalibration(id, display, GetTouchCalibrator(),
                                          error)) {
     return false;
   }
 
   touch_calibration_target_id_ = id;
   custom_touch_calibration_active_ = true;
 
   // Enable un-transformed touch input.
   ash::Shell::GetInstance()->touch_transformer_controller()->SetForCalibration(
       true);
   return true;
 }
 
 bool DisplayInfoProviderChromeOS::CompleteCustomTouchCalibration(
     const api::system_display::TouchCalibrationPairQuad& pairs,
     const api::system_display::Bounds& bounds,
     std::string* error) {
-  if (ash_util::IsRunningInMash()) {
+  if (IsRunningInMash()) {
     // TODO(crbug.com/682402): Mash support.
     NOTIMPLEMENTED();
     return false;
   }
   VLOG(1) << "CompleteCustomTouchCalibration: " << touch_calibration_target_id_;
 
   ash::Shell::GetInstance()->touch_transformer_controller()->SetForCalibration(
       false);
 
   const display::Display display = GetDisplay(touch_calibration_target_id_);
@@ skipping 42 matching lines @@
   }
 
   gfx::Size display_size(bounds.width, bounds.height);
   ash::Shell::GetInstance()->display_manager()->SetTouchCalibrationData(
       display.id(), calibration_points, display_size);
   return true;
 }
 
 bool DisplayInfoProviderChromeOS::ClearTouchCalibration(const std::string& id,
                                                         std::string* error) {
-  if (ash_util::IsRunningInMash()) {
+  if (IsRunningInMash()) {
     // TODO(crbug.com/682402): Mash support.
     NOTIMPLEMENTED();
     *error = "Not implemented for mash.";
     return false;
   }
   const display::Display display = GetDisplay(id);
 
   if (!ValidateParamsForTouchCalibration(id, display, GetTouchCalibrator(),
                                          error)) {
     return false;
@@ skipping 28 matching lines @@
     touch_calibrator_.reset(new chromeos::TouchCalibratorController);
   return touch_calibrator_.get();
 }
 
 // static
 DisplayInfoProvider* DisplayInfoProvider::Create() {
   return new DisplayInfoProviderChromeOS();
 }
 
 }  // namespace extensions