mash: Work around startup crash in extensions::DisplayInfoProviderChromeOS

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"
 #include "ash/shell.h"
 #include "ash/touch/ash_touch_transform_controller.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/chromeos/display/display_preferences.h"
 #include "chrome/browser/chromeos/display/overscan_calibrator.h"
 #include "chrome/browser/chromeos/display/touch_calibrator/touch_calibrator_controller.h"
+#include "chrome/browser/ui/ash/ash_util.h"
 #include "extensions/common/api/system_display.h"
 #include "ui/display/display.h"
 #include "ui/display/display_layout.h"
 #include "ui/display/display_layout_builder.h"
 #include "ui/display/manager/display_manager.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace extensions {
@@ skipping 410 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 (chrome::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();
 
   const display::Display target = GetDisplay(display_id_str);
 
   if (target.id() == display::kInvalidDisplayId) {
     *error = "Display not found.";
     return false;
@@ skipping 48 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 (chrome::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;
   builder.ClearPlacements();
   for (const system_display::DisplayLayout& layout : layouts) {
     display::Display display = GetDisplay(layout.id);
     if (display.id() == display::kInvalidDisplayId) {
@@ skipping 22 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 (chrome::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());
   }
 
   const display::ManagedDisplayInfo& display_info =
       display_manager->GetDisplayInfo(display.id());
@@ skipping 11 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 (chrome::IsRunningInMash()) {
+    // TODO(crbug.com/682402): Mash support.
+    NOTIMPLEMENTED();
+    return;
+  }
   ash::Shell::GetInstance()->display_manager()->SetUnifiedDesktopEnabled(
       enable);
 }
 
 DisplayInfoProvider::DisplayUnitInfoList
 DisplayInfoProviderChromeOS::GetAllDisplaysInfo() {
+  if (chrome::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 (chrome::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();
 
   display::Screen* screen = display::Screen::GetScreen();
   std::vector<display::Display> displays = screen->GetAllDisplays();
 
   DisplayLayoutList result;
   for (const display::Display& display : displays) {
     const display::DisplayPlacement placement =
         display_manager->GetCurrentResolvedDisplayLayout().FindPlacementById(
             display.id());
     if (placement.display_id == display::kInvalidDisplayId)
       continue;
     system_display::DisplayLayout display_layout;
     display_layout.id = base::Int64ToString(placement.display_id);
     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 (chrome::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(
           display.id());
   overscan_calibrators_[id].reset(
       new chromeos::OverscanCalibrator(display, insets));
   return true;
@@ skipping 29 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 (chrome::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 (chrome::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 (chrome::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_);
   touch_calibration_target_id_.clear();
 
   // If Complete() is called before calling Start(), throw an error.
   if (!custom_touch_calibration_active_) {
@@ skipping 38 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 (chrome::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;
   }
 
   ash::Shell::GetInstance()->display_manager()->ClearTouchCalibrationData(
       display.id());
   return true;
@@ skipping 23 matching lines @@
     touch_calibrator_.reset(new chromeos::TouchCalibratorController);
   return touch_calibrator_.get();
 }
 
 // static
 DisplayInfoProvider* DisplayInfoProvider::Create() {
   return new DisplayInfoProviderChromeOS();
 }
 
 }  // namespace extensions