Replace OutputSnapshot |is_internal| with check against 'type == OUTPUT_TYPE_INTERNAL'

chromeos/display/output_configurator.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 "chromeos/display/output_configurator.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/Xrandr.h>
 #include <X11/extensions/XInput2.h>
 
@@ skipping 76 matching lines @@
 // on/off state of each corresponding entry in |outputs|.
 int GetOutputPower(
     const std::vector<OutputConfigurator::OutputSnapshot>& outputs,
     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].is_internal;
+    bool internal = outputs[i].type == OUTPUT_TYPE_INTERNAL;
     bool on = state == DISPLAY_POWER_ALL_ON ||
         (state == DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON && !internal) ||
         (state == DISPLAY_POWER_INTERNAL_ON_EXTERNAL_OFF && internal);
     if (output_power)
       (*output_power)[i] = on;
     if (on)
       num_on_outputs++;
   }
   return num_on_outputs;
 }
 
 // Determine if there is an "internal" output and how many outputs are
 // connected.
 bool IsProjecting(
     const std::vector<OutputConfigurator::OutputSnapshot>& outputs) {
   bool has_internal_output = false;
   int connected_output_count = outputs.size();
   for (size_t i = 0; i < outputs.size(); ++i)
-    has_internal_output |= outputs[i].is_internal;
+    has_internal_output |= outputs[i].type == OUTPUT_TYPE_INTERNAL;
 
   // "Projecting" is defined as having more than 1 output connected while at
   // least one of them is an internal output.
   return has_internal_output && (connected_output_count > 1);
 }
 
 }  // namespace
 
 OutputConfigurator::ModeInfo::ModeInfo()
     : width(0),
@@ skipping 20 matching lines @@
     : output(None),
       crtc(None),
       current_mode(None),
       native_mode(None),
       mirror_mode(None),
       selected_mode(None),
       x(0),
       y(0),
       width_mm(0),
       height_mm(0),
-      is_internal(false),
       is_aspect_preserving_scaling(false),
       type(OUTPUT_TYPE_UNKNOWN),
       touch_device_id(0),
       display_id(0),
       has_display_id(false),
       index(0) {}
 
 OutputConfigurator::OutputSnapshot::~OutputSnapshot() {}
 
 void OutputConfigurator::TestApi::SendScreenChangeEvent() {
@@ skipping 309 matching lines @@
   delegate_->GrabServer();
   UpdateCachedOutputs();
 
   const OutputState new_state = ChooseOutputState(power_state);
   bool attempted_change = false;
   bool success = false;
 
   bool only_if_single_internal_display =
       flags & kSetDisplayPowerOnlyIfSingleInternalDisplay;
   bool single_internal_display =
-      cached_outputs_.size() == 1 && cached_outputs_[0].is_internal;
+      cached_outputs_.size() == 1 &&
+      cached_outputs_[0].type == OUTPUT_TYPE_INTERNAL;
   if (single_internal_display || !only_if_single_internal_display) {
     success = EnterStateOrFallBackToSoftwareMirroring(new_state, power_state);
     attempted_change = true;
 
     // Force the DPMS on since the driver doesn't always detect that it
     // should turn on. This is needed when coming back from idle suspend.
     if (success && power_state != DISPLAY_POWER_ALL_OFF)
       delegate_->ForceDPMSOn();
   }
 
@@ skipping 160 matching lines @@
             FindOutputModeMatchingSize(*output, width, height);
       }
     }
     // Fall back to native mode.
     if (output->selected_mode == None)
       output->selected_mode = output->native_mode;
   }
 
   // Set |mirror_mode| fields.
   if (cached_outputs_.size() == 2) {
-    bool one_is_internal = cached_outputs_[0].is_internal;
-    bool two_is_internal = cached_outputs_[1].is_internal;
+    bool one_is_internal = cached_outputs_[0].type == OUTPUT_TYPE_INTERNAL;
+    bool two_is_internal = cached_outputs_[1].type == OUTPUT_TYPE_INTERNAL;
     int internal_outputs = (one_is_internal ? 1 : 0) +
         (two_is_internal ? 1 : 0);
     DCHECK_LT(internal_outputs, 2);
     LOG_IF(WARNING, internal_outputs == 2)
         << "Two internal outputs detected.";
 
     bool can_mirror = false;
     for (int attempt = 0; !can_mirror && attempt < 2; ++attempt) {
       // Try preserving external output's aspect ratio on the first attempt.
       // If that fails, fall back to the highest matching resolution.
@@ skipping 450 matching lines @@
   float width_ratio = static_cast<float>(mirror_mode_info->width) /
       static_cast<float>(native_mode_info->width);
   float height_ratio = static_cast<float>(mirror_mode_info->height) /
       static_cast<float>(native_mode_info->height);
 
   area_ratio = width_ratio * height_ratio;
   return area_ratio;
 }
 
 }  // namespace chromeos