Renamed OutputConfigurator to DisplayConfigurator

ui/display/chromeos/display_configurator.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 "ui/display/chromeos/output_configurator.h"
+#include "ui/display/chromeos/display_configurator.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
 #include "ui/display/chromeos/display_mode.h"
 #include "ui/display/chromeos/display_snapshot.h"
@@ skipping 48 matching lines @@
     case OUTPUT_STATE_DUAL_EXTENDED:
       return "DUAL_EXTENDED";
   }
   NOTREACHED() << "Unknown state " << state;
   return "INVALID";
 }
 
 // Returns the number of outputs in |outputs| that should be turned on, per
 // |state|.  If |output_power| is non-NULL, it is updated to contain the
 // on/off state of each corresponding entry in |outputs|.
-int GetOutputPower(const std::vector<OutputConfigurator::DisplayState>& outputs,
-                   chromeos::DisplayPowerState state,
-                   std::vector<bool>* output_power) {
+int GetOutputPower(
+    const std::vector<DisplayConfigurator::DisplayState>& outputs,
+    chromeos::DisplayPowerState state,
+    std::vector<bool>* output_power) {
   int num_on_outputs = 0;
   if (output_power)
     output_power->resize(outputs.size());
 
   for (size_t i = 0; i < outputs.size(); ++i) {
     bool internal = outputs[i].display->type() == OUTPUT_TYPE_INTERNAL;
     bool on =
         state == chromeos::DISPLAY_POWER_ALL_ON ||
         (state == chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON &&
          !internal) ||
         (state == chromeos::DISPLAY_POWER_INTERNAL_ON_EXTERNAL_OFF && internal);
     if (output_power)
       (*output_power)[i] = on;
     if (on)
       num_on_outputs++;
   }
   return num_on_outputs;
 }
 
 }  // namespace
 
-OutputConfigurator::CoordinateTransformation::CoordinateTransformation()
+DisplayConfigurator::CoordinateTransformation::CoordinateTransformation()
     : x_scale(1.0),
       x_offset(0.0),
       y_scale(1.0),
       y_offset(0.0) {}
 
-OutputConfigurator::DisplayState::DisplayState()
+DisplayConfigurator::DisplayState::DisplayState()
     : display(NULL),
       touch_device_id(0),
       selected_mode(NULL),
       mirror_mode(NULL) {}
 
-bool OutputConfigurator::TestApi::TriggerConfigureTimeout() {
+bool DisplayConfigurator::TestApi::TriggerConfigureTimeout() {
   if (configurator_->configure_timer_.get() &&
       configurator_->configure_timer_->IsRunning()) {
     configurator_->configure_timer_.reset();
     configurator_->ConfigureOutputs();
     return true;
   } else {
     return false;
   }
 }
 
 // static
-const DisplayMode* OutputConfigurator::FindDisplayModeMatchingSize(
+const DisplayMode* DisplayConfigurator::FindDisplayModeMatchingSize(
     const DisplaySnapshot& output,
     const gfx::Size& size) {
   const DisplayMode* best_mode = NULL;
   for (DisplayModeList::const_iterator it = output.modes().begin();
        it != output.modes().end();
        ++it) {
     const DisplayMode* mode = *it;
 
     if (mode->size() != size)
       continue;
@@ skipping 16 matching lines @@
     }
     if (mode->refresh_rate() < best_mode->refresh_rate())
       continue;
 
     best_mode = mode;
   }
 
   return best_mode;
 }
 
-OutputConfigurator::OutputConfigurator()
+DisplayConfigurator::DisplayConfigurator()
     : state_controller_(NULL),
       mirroring_controller_(NULL),
       is_panel_fitting_enabled_(false),
       configure_display_(base::SysInfo::IsRunningOnChromeOS()),
       output_state_(OUTPUT_STATE_INVALID),
       power_state_(chromeos::DISPLAY_POWER_ALL_ON),
       next_output_protection_client_id_(1) {}
 
-OutputConfigurator::~OutputConfigurator() {
+DisplayConfigurator::~DisplayConfigurator() {
   if (native_display_delegate_)
     native_display_delegate_->RemoveObserver(this);
 }
 
-void OutputConfigurator::SetNativeDisplayDelegateForTesting(
+void DisplayConfigurator::SetNativeDisplayDelegateForTesting(
     scoped_ptr<NativeDisplayDelegate> delegate) {
   DCHECK(!native_display_delegate_);
 
   native_display_delegate_ = delegate.Pass();
   native_display_delegate_->AddObserver(this);
   configure_display_ = true;
 }
 
-void OutputConfigurator::SetTouchscreenDelegateForTesting(
+void DisplayConfigurator::SetTouchscreenDelegateForTesting(
     scoped_ptr<TouchscreenDelegate> delegate) {
   DCHECK(!touchscreen_delegate_);
 
   touchscreen_delegate_ = delegate.Pass();
 }
 
-void OutputConfigurator::SetInitialDisplayPower(
+void DisplayConfigurator::SetInitialDisplayPower(
     chromeos::DisplayPowerState power_state) {
   DCHECK_EQ(output_state_, OUTPUT_STATE_INVALID);
   power_state_ = power_state;
 }
 
-void OutputConfigurator::Init(bool is_panel_fitting_enabled) {
+void DisplayConfigurator::Init(bool is_panel_fitting_enabled) {
   is_panel_fitting_enabled_ = is_panel_fitting_enabled;
   if (!configure_display_)
     return;
 
   if (!native_display_delegate_) {
 #if defined(USE_OZONE)
     native_display_delegate_.reset(new NativeDisplayDelegateOzone());
 #elif defined(USE_X11)
     native_display_delegate_.reset(new NativeDisplayDelegateX11());
 #else
     NOTREACHED();
 #endif
     native_display_delegate_->AddObserver(this);
   }
 
   if (!touchscreen_delegate_) {
 #if defined(USE_OZONE)
     touchscreen_delegate_.reset(new TouchscreenDelegateOzone());
 #elif defined(USE_X11)
     touchscreen_delegate_.reset(new TouchscreenDelegateX11());
 #else
     NOTREACHED();
 #endif
   }
 }
 
-void OutputConfigurator::ForceInitialConfigure(uint32_t background_color_argb) {
+void DisplayConfigurator::ForceInitialConfigure(
+    uint32_t background_color_argb) {
   if (!configure_display_)
     return;
 
   native_display_delegate_->GrabServer();
   native_display_delegate_->Initialize();
 
   UpdateCachedOutputs();
   if (cached_outputs_.size() > 1 && background_color_argb)
     native_display_delegate_->SetBackgroundColor(background_color_argb);
   const OutputState new_state = ChooseOutputState(power_state_);
   const bool success =
       EnterStateOrFallBackToSoftwareMirroring(new_state, power_state_);
 
   // Force the DPMS on chrome startup as the driver doesn't always detect
   // that all displays are on when signing out.
   native_display_delegate_->ForceDPMSOn();
   native_display_delegate_->UngrabServer();
   NotifyObservers(success, new_state);
 }
 
-bool OutputConfigurator::ApplyProtections(const DisplayProtections& requests) {
+bool DisplayConfigurator::ApplyProtections(const DisplayProtections& requests) {
   for (DisplayStateList::const_iterator it = cached_outputs_.begin();
        it != cached_outputs_.end();
        ++it) {
     uint32_t all_desired = 0;
     DisplayProtections::const_iterator request_it =
         requests.find(it->display->display_id());
     if (request_it != requests.end())
       all_desired = request_it->second;
     switch (it->display->type()) {
       case OUTPUT_TYPE_UNKNOWN:
@@ skipping 17 matching lines @@
         break;
       case OUTPUT_TYPE_NONE:
         NOTREACHED();
         break;
     }
   }
 
   return true;
 }
 
-OutputConfigurator::OutputProtectionClientId
-OutputConfigurator::RegisterOutputProtectionClient() {
+DisplayConfigurator::OutputProtectionClientId
+DisplayConfigurator::RegisterOutputProtectionClient() {
   if (!configure_display_)
     return kInvalidClientId;
 
   return next_output_protection_client_id_++;
 }
 
-void OutputConfigurator::UnregisterOutputProtectionClient(
+void DisplayConfigurator::UnregisterOutputProtectionClient(
     OutputProtectionClientId client_id) {
   client_protection_requests_.erase(client_id);
 
   DisplayProtections protections;
   for (ProtectionRequests::const_iterator it =
            client_protection_requests_.begin();
        it != client_protection_requests_.end();
        ++it) {
     for (DisplayProtections::const_iterator it2 = it->second.begin();
          it2 != it->second.end();
          ++it2) {
       protections[it2->first] |= it2->second;
     }
   }
 
   ApplyProtections(protections);
 }
 
-bool OutputConfigurator::QueryOutputProtectionStatus(
+bool DisplayConfigurator::QueryOutputProtectionStatus(
     OutputProtectionClientId client_id,
     int64_t display_id,
     uint32_t* link_mask,
     uint32_t* protection_mask) {
   if (!configure_display_)
     return false;
 
   uint32_t enabled = 0;
   uint32_t unfulfilled = 0;
   *link_mask = 0;
@@ skipping 36 matching lines @@
     uint32_t requested_mask = 0;
     if (it->second.find(display_id) != it->second.end())
       requested_mask = it->second[display_id];
     *protection_mask = enabled & ~unfulfilled & requested_mask;
   } else {
     *protection_mask = 0;
   }
   return true;
 }
 
-bool OutputConfigurator::EnableOutputProtection(
+bool DisplayConfigurator::EnableOutputProtection(
     OutputProtectionClientId client_id,
     int64_t display_id,
     uint32_t desired_method_mask) {
   if (!configure_display_)
     return false;
 
   DisplayProtections protections;
   for (ProtectionRequests::const_iterator it =
            client_protection_requests_.begin();
        it != client_protection_requests_.end();
@@ skipping 19 matching lines @@
         client_protection_requests_.erase(client_id);
     }
   } else {
     client_protection_requests_[client_id][display_id] = desired_method_mask;
   }
 
   return true;
 }
 
 std::vector<ui::ColorCalibrationProfile>
-OutputConfigurator::GetAvailableColorCalibrationProfiles(
-    int64_t display_id) {
+DisplayConfigurator::GetAvailableColorCalibrationProfiles(int64_t display_id) {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableDisplayColorCalibration)) {
     for (size_t i = 0; i < cached_outputs_.size(); ++i) {
       if (cached_outputs_[i].display &&
           cached_outputs_[i].display->display_id() == display_id) {
         return native_display_delegate_->GetAvailableColorCalibrationProfiles(
             *cached_outputs_[i].display);
       }
     }
   }
 
   return std::vector<ui::ColorCalibrationProfile>();
 }
 
-bool OutputConfigurator::SetColorCalibrationProfile(
+bool DisplayConfigurator::SetColorCalibrationProfile(
     int64_t display_id,
     ui::ColorCalibrationProfile new_profile) {
   for (size_t i = 0; i < cached_outputs_.size(); ++i) {
     if (cached_outputs_[i].display &&
         cached_outputs_[i].display->display_id() == display_id) {
       return native_display_delegate_->SetColorCalibrationProfile(
           *cached_outputs_[i].display, new_profile);
     }
   }
 
   return false;
 }
 
-void OutputConfigurator::PrepareForExit() {
+void DisplayConfigurator::PrepareForExit() {
   configure_display_ = false;
 }
 
-bool OutputConfigurator::SetDisplayPower(
+bool DisplayConfigurator::SetDisplayPower(
     chromeos::DisplayPowerState power_state,
     int flags) {
   if (!configure_display_)
     return false;
 
   VLOG(1) << "SetDisplayPower: power_state="
           << DisplayPowerStateToString(power_state) << " flags=" << flags
           << ", configure timer="
           << ((configure_timer_.get() && configure_timer_->IsRunning()) ?
                   "Running" : "Stopped");
@@ skipping 21 matching lines @@
     if (success && power_state != chromeos::DISPLAY_POWER_ALL_OFF)
       native_display_delegate_->ForceDPMSOn();
   }
 
   native_display_delegate_->UngrabServer();
   if (attempted_change)
     NotifyObservers(success, new_state);
   return true;
 }
 
-bool OutputConfigurator::SetDisplayMode(OutputState new_state) {
+bool DisplayConfigurator::SetDisplayMode(OutputState new_state) {
   if (!configure_display_)
     return false;
 
   VLOG(1) << "SetDisplayMode: state=" << OutputStateToString(new_state);
   if (output_state_ == new_state) {
     // Cancel software mirroring if the state is moving from
     // OUTPUT_STATE_DUAL_EXTENDED to OUTPUT_STATE_DUAL_EXTENDED.
     if (mirroring_controller_ && new_state == OUTPUT_STATE_DUAL_EXTENDED)
       mirroring_controller_->SetSoftwareMirroring(false);
     NotifyObservers(true, new_state);
     return true;
   }
 
   native_display_delegate_->GrabServer();
   UpdateCachedOutputs();
   const bool success =
       EnterStateOrFallBackToSoftwareMirroring(new_state, power_state_);
   native_display_delegate_->UngrabServer();
 
   NotifyObservers(success, new_state);
   return success;
 }
 
-void OutputConfigurator::OnConfigurationChanged() {
+void DisplayConfigurator::OnConfigurationChanged() {
   // Configure outputs with |kConfigureDelayMs| delay,
   // so that time-consuming ConfigureOutputs() won't be called multiple times.
   if (configure_timer_.get()) {
     configure_timer_->Reset();
   } else {
-    configure_timer_.reset(new base::OneShotTimer<OutputConfigurator>());
+    configure_timer_.reset(new base::OneShotTimer<DisplayConfigurator>());
     configure_timer_->Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(kConfigureDelayMs),
         this,
-        &OutputConfigurator::ConfigureOutputs);
+        &DisplayConfigurator::ConfigureOutputs);
   }
 }
 
-void OutputConfigurator::AddObserver(Observer* observer) {
+void DisplayConfigurator::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
-void OutputConfigurator::RemoveObserver(Observer* observer) {
+void DisplayConfigurator::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void OutputConfigurator::SuspendDisplays() {
+void DisplayConfigurator::SuspendDisplays() {
   // If the display is off due to user inactivity and there's only a single
   // internal display connected, switch to the all-on state before
   // suspending.  This shouldn't be very noticeable to the user since the
   // backlight is off at this point, and doing this lets us resume directly
   // into the "on" state, which greatly reduces resume times.
   if (power_state_ == chromeos::DISPLAY_POWER_ALL_OFF) {
     SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
                     kSetDisplayPowerOnlyIfSingleInternalDisplay);
 
     // We need to make sure that the monitor configuration we just did actually
     // completes before we return, because otherwise the X message could be
     // racing with the HandleSuspendReadiness message.
     native_display_delegate_->SyncWithServer();
   }
 }
 
-void OutputConfigurator::ResumeDisplays() {
+void DisplayConfigurator::ResumeDisplays() {
   // Force probing to ensure that we pick up any changes that were made
   // while the system was suspended.
   SetDisplayPower(power_state_, kSetDisplayPowerForceProbe);
 }
 
-void OutputConfigurator::UpdateCachedOutputs() {
+void DisplayConfigurator::UpdateCachedOutputs() {
   std::vector<DisplaySnapshot*> snapshots =
       native_display_delegate_->GetOutputs();
 
   cached_outputs_.clear();
   for (size_t i = 0; i < snapshots.size(); ++i) {
     DisplayState display_state;
     display_state.display = snapshots[i];
     cached_outputs_.push_back(display_state);
   }
 
@@ skipping 55 matching lines @@
           // it will succeed with the other.  This way we will have the correct
           // aspect ratio on at least one of them.
           can_mirror = FindMirrorMode(
               &cached_outputs_[1], &cached_outputs_[0], false, preserve_aspect);
         }
       }
     }
   }
 }
 
-bool OutputConfigurator::FindMirrorMode(DisplayState* internal_output,
-                                        DisplayState* external_output,
-                                        bool try_panel_fitting,
-                                        bool preserve_aspect) {
+bool DisplayConfigurator::FindMirrorMode(DisplayState* internal_output,
+                                         DisplayState* external_output,
+                                         bool try_panel_fitting,
+                                         bool preserve_aspect) {
   const DisplayMode* internal_native_info =
       internal_output->display->native_mode();
   const DisplayMode* external_native_info =
       external_output->display->native_mode();
   if (!internal_native_info || !external_native_info)
     return false;
 
   // Check if some external output resolution can be mirrored on internal.
   // Prefer the modes in the order that X sorts them, assuming this is the order
   // in which they look better on the monitor.
@@ skipping 40 matching lines @@
         internal_output->mirror_mode = *external_it;
         external_output->mirror_mode = *external_it;
         return true;  // Mirror mode created.
       }
     }
   }
 
   return false;
 }
 
-void OutputConfigurator::ConfigureOutputs() {
+void DisplayConfigurator::ConfigureOutputs() {
   configure_timer_.reset();
 
   if (!configure_display_)
     return;
 
   native_display_delegate_->GrabServer();
   UpdateCachedOutputs();
   const OutputState new_state = ChooseOutputState(power_state_);
   const bool success =
       EnterStateOrFallBackToSoftwareMirroring(new_state, power_state_);
   native_display_delegate_->UngrabServer();
 
   NotifyObservers(success, new_state);
 }
 
-void OutputConfigurator::NotifyObservers(bool success,
-                                         OutputState attempted_state) {
+void DisplayConfigurator::NotifyObservers(bool success,
+                                          OutputState attempted_state) {
   if (success) {
     FOR_EACH_OBSERVER(
         Observer, observers_, OnDisplayModeChanged(cached_outputs_));
   } else {
     FOR_EACH_OBSERVER(
         Observer, observers_, OnDisplayModeChangeFailed(attempted_state));
   }
 }
 
-bool OutputConfigurator::EnterStateOrFallBackToSoftwareMirroring(
+bool DisplayConfigurator::EnterStateOrFallBackToSoftwareMirroring(
     OutputState output_state,
     chromeos::DisplayPowerState power_state) {
   bool success = EnterState(output_state, power_state);
   if (mirroring_controller_) {
     bool enable_software_mirroring = false;
     if (!success && output_state == OUTPUT_STATE_DUAL_MIRROR) {
       if (output_state_ != OUTPUT_STATE_DUAL_EXTENDED ||
           power_state_ != power_state)
         EnterState(OUTPUT_STATE_DUAL_EXTENDED, power_state);
       enable_software_mirroring = success =
           output_state_ == OUTPUT_STATE_DUAL_EXTENDED;
     }
     mirroring_controller_->SetSoftwareMirroring(enable_software_mirroring);
   }
   return success;
 }
 
-bool OutputConfigurator::EnterState(OutputState output_state,
-                                    chromeos::DisplayPowerState power_state) {
+bool DisplayConfigurator::EnterState(OutputState output_state,
+                                     chromeos::DisplayPowerState power_state) {
   std::vector<bool> output_power;
   int num_on_outputs =
       GetOutputPower(cached_outputs_, power_state, &output_power);
   VLOG(1) << "EnterState: output=" << OutputStateToString(output_state)
           << " power=" << DisplayPowerStateToString(power_state);
 
   // Framebuffer dimensions.
   gfx::Size size;
 
   std::vector<gfx::Point> new_origins(cached_outputs_.size(), gfx::Point());
@@ skipping 168 matching lines @@
     }
   }
 
   if (all_succeeded) {
     output_state_ = output_state;
     power_state_ = power_state;
   }
   return all_succeeded;
 }
 
-OutputState OutputConfigurator::ChooseOutputState(
+OutputState DisplayConfigurator::ChooseOutputState(
     chromeos::DisplayPowerState power_state) const {
   int num_on_outputs = GetOutputPower(cached_outputs_, power_state, NULL);
   switch (cached_outputs_.size()) {
     case 0:
       return OUTPUT_STATE_HEADLESS;
     case 1:
       return OUTPUT_STATE_SINGLE;
     case 2: {
       if (num_on_outputs == 1) {
         // If only one output is currently turned on, return the "single"
@@ skipping 13 matching lines @@
         }
         return state_controller_->GetStateForDisplayIds(display_ids);
       }
     }
     default:
       NOTREACHED();
   }
   return OUTPUT_STATE_INVALID;
 }
 
-OutputConfigurator::CoordinateTransformation
-OutputConfigurator::GetMirrorModeCTM(const DisplayState& output) {
+DisplayConfigurator::CoordinateTransformation
+DisplayConfigurator::GetMirrorModeCTM(const DisplayState& output) {
   CoordinateTransformation ctm;  // Default to identity
   const DisplayMode* native_mode_info = output.display->native_mode();
   const DisplayMode* mirror_mode_info = output.mirror_mode;
 
   if (!native_mode_info || !mirror_mode_info ||
       native_mode_info->size().height() == 0 ||
       mirror_mode_info->size().height() == 0 ||
       native_mode_info->size().width() == 0 ||
       mirror_mode_info->size().width() == 0)
     return ctm;
@@ skipping 14 matching lines @@
     ctm.y_scale = 1.0;
     ctm.y_offset = 0.0;
     ctm.x_scale = native_mode_ar / mirror_mode_ar;
     ctm.x_offset = (mirror_mode_ar / native_mode_ar - 1.0) * 0.5;
     return ctm;
   }
 
   return ctm;  // Same aspect ratio - return identity
 }
 
-OutputConfigurator::CoordinateTransformation
-OutputConfigurator::GetExtendedModeCTM(const DisplayState& output,
-                                       const gfx::Point& new_origin,
-                                       const gfx::Size& framebuffer_size) {
+DisplayConfigurator::CoordinateTransformation
+DisplayConfigurator::GetExtendedModeCTM(const DisplayState& output,
+                                        const gfx::Point& new_origin,
+                                        const gfx::Size& framebuffer_size) {
   CoordinateTransformation ctm;  // Default to identity
   const DisplayMode* mode_info = output.selected_mode;
   DCHECK(mode_info);
   if (!mode_info)
     return ctm;
   // An example of how to calculate the CTM.
   // Suppose we have 2 monitors, the first one has size 1366 x 768.
   // The second one has size 2560 x 1600
   // The total size of framebuffer is 2560 x 2428
   // where 2428 = 768 + 60 (hidden gap) + 1600
   // and the sceond monitor is translated to Point (0, 828) in the
   // framebuffer.
   // X will first map input event location to [0, 2560) x [0, 2428),
   // then apply CTM on it.
   // So to compute CTM, for monitor1, we have
   // x_scale = (1366 - 1) / (2560 - 1)
   // x_offset = 0 / (2560 - 1)
   // y_scale = (768 - 1) / (2428 - 1)
   // y_offset = 0 / (2428 -1)
   // For Monitor 2, we have
   // x_scale = (2560 - 1) / (2560 - 1)
   // x_offset = 0 / (2560 - 1)
   // y_scale = (1600 - 1) / (2428 - 1)
   // y_offset = 828 / (2428 -1)
-  // See the unittest OutputConfiguratorTest.CTMForMultiScreens.
+  // See the unittest DisplayConfiguratorTest.CTMForMultiScreens.
   ctm.x_scale = static_cast<float>(mode_info->size().width() - 1) /
                 (framebuffer_size.width() - 1);
   ctm.x_offset =
       static_cast<float>(new_origin.x()) / (framebuffer_size.width() - 1);
   ctm.y_scale = static_cast<float>(mode_info->size().height() - 1) /
                 (framebuffer_size.height() - 1);
   ctm.y_offset =
       static_cast<float>(new_origin.y()) / (framebuffer_size.height() - 1);
   return ctm;
 }
 
-float OutputConfigurator::GetMirroredDisplayAreaRatio(
+float DisplayConfigurator::GetMirroredDisplayAreaRatio(
     const DisplayState& output) {
   float area_ratio = 1.0f;
   const DisplayMode* native_mode_info = output.display->native_mode();
   const DisplayMode* mirror_mode_info = output.mirror_mode;
 
   if (!native_mode_info || !mirror_mode_info ||
       native_mode_info->size().height() == 0 ||
       mirror_mode_info->size().height() == 0 ||
       native_mode_info->size().width() == 0 ||
       mirror_mode_info->size().width() == 0)
     return area_ratio;
 
   float width_ratio = static_cast<float>(mirror_mode_info->size().width()) /
                       static_cast<float>(native_mode_info->size().width());
   float height_ratio = static_cast<float>(mirror_mode_info->size().height()) /
                        static_cast<float>(native_mode_info->size().height());
 
   area_ratio = width_ratio * height_ratio;
   return area_ratio;
 }
 
 }  // namespace ui