Chrome OS: avoid suspending on lid close when casting is active.

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 88 matching lines @@
         (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].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),
       height(0),
       interlaced(false),
       refresh_rate(0.0) {}
 
 OutputConfigurator::ModeInfo::ModeInfo(int width,
                                        int height,
@@ skipping 112 matching lines @@
 }
 
 OutputConfigurator::OutputConfigurator()
     : state_controller_(NULL),
       mirroring_controller_(NULL),
       is_panel_fitting_enabled_(false),
       configure_display_(base::SysInfo::IsRunningOnChromeOS()),
       xrandr_event_base_(0),
       output_state_(STATE_INVALID),
       power_state_(DISPLAY_POWER_ALL_ON),
-      next_output_protection_client_id_(1) {
+      next_output_protection_client_id_(1),
+      casting_session_count_(0) {
 }
 
 OutputConfigurator::~OutputConfigurator() {}
 
 void OutputConfigurator::SetDelegateForTesting(scoped_ptr<Delegate> delegate) {
   delegate_ = delegate.Pass();
   configure_display_ = true;
 }
 
 void OutputConfigurator::SetInitialDisplayPower(DisplayPowerState power_state) {
@@ skipping 21 matching lines @@
   if (cached_outputs_.size() > 1 && background_color_argb)
     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.
   delegate_->ForceDPMSOn();
   delegate_->UngrabServer();
-  delegate_->SendProjectingStateToPowerManager(IsProjecting(cached_outputs_));
+  SendProjectingStateToPowerManager();
   NotifyObservers(success, new_state);
 }
 
 bool OutputConfigurator::ApplyProtections(const DisplayProtections& requests) {
   for (std::vector<OutputSnapshot>::const_iterator it = cached_outputs_.begin();
        it != cached_outputs_.end(); ++it) {
     RROutput this_id = it->output;
     uint32_t all_desired = 0;
     DisplayProtections::const_iterator request_it = requests.find(
         it->display_id);
@@ skipping 20 matching lines @@
         break;
       case OUTPUT_TYPE_NONE:
         NOTREACHED();
         break;
     }
   }
 
   return true;
 }
 
+void OutputConfigurator::SendProjectingStateToPowerManager() {
+  bool has_internal_output = false;
+  int connected_output_count = cached_outputs_.size() + casting_session_count_;
+  for (size_t i = 0; i < cached_outputs_.size(); ++i) {
+    if (cached_outputs_[i].type == OUTPUT_TYPE_INTERNAL) {
+      has_internal_output = true;
+      break;
+    }
+  }
+
+  // "Projecting" is defined as having more than 1 output connected while at
+  // least one of them is an internal output.
+  bool is_projecting = has_internal_output && (connected_output_count > 1);
+  delegate_->SendProjectingStateToPowerManager(is_projecting);
+}
+
 OutputConfigurator::OutputProtectionClientId
 OutputConfigurator::RegisterOutputProtectionClient() {
   if (!configure_display_)
     return kInvalidClientId;
 
   return next_output_protection_client_id_++;
 }
 
 void OutputConfigurator::UnregisterOutputProtectionClient(
     OutputProtectionClientId client_id) {
@@ skipping 244 matching lines @@
     // This also takes care of same event being received twice.
     ScheduleConfigureOutputs();
   }
 
   return base::EVENT_CONTINUE;
 }
 
 void OutputConfigurator::DidProcessEvent(const base::NativeEvent& event) {
 }
 
+void OutputConfigurator::OnCastingSessionStartedOrStopped(bool started) {
+  if (started) {
+    ++casting_session_count_;
+  } else {
+    DCHECK_GT(casting_session_count_, 0);
+    --casting_session_count_;
+    if (casting_session_count_ < 0)
+      casting_session_count_ = 0;
+  }
+  SendProjectingStateToPowerManager();
+}
+
 void OutputConfigurator::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void OutputConfigurator::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void OutputConfigurator::SuspendDisplays() {
   // If the display is off due to user inactivity and there's only a single
@@ skipping 158 matching lines @@
   configure_timer_.reset();
 
   delegate_->GrabServer();
   UpdateCachedOutputs();
   const OutputState new_state = ChooseOutputState(power_state_);
   const bool success = EnterStateOrFallBackToSoftwareMirroring(
       new_state, power_state_);
   delegate_->UngrabServer();
 
   NotifyObservers(success, new_state);
-  delegate_->SendProjectingStateToPowerManager(IsProjecting(cached_outputs_));
+  SendProjectingStateToPowerManager();
 }
 
 void OutputConfigurator::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));
@@ skipping 339 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