Add support for a virtual display on ChromeOS

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/display_configurator.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
+#include "ui/display/chromeos/display_snapshot_virtual.h"
 #include "ui/display/chromeos/display_util.h"
 #include "ui/display/chromeos/update_display_configuration_task.h"
 #include "ui/display/display_switches.h"
 #include "ui/display/types/display_mode.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/display/types/native_display_delegate.h"
+#include "ui/gfx/display.h"
 
 namespace ui {
 
 namespace {
 
 typedef std::vector<const DisplayMode*> DisplayModeList;
 
 // The delay to perform configuration after RRNotify. See the comment for
 // |configure_timer_|.
 const int kConfigureDelayMs = 500;
@@ skipping 107 matching lines @@
 std::vector<DisplayConfigurator::DisplayState>
 DisplayConfigurator::DisplayLayoutManagerImpl::ParseDisplays(
     const std::vector<DisplaySnapshot*>& snapshots) const {
   std::vector<DisplayState> cached_displays;
   for (auto snapshot : snapshots) {
     DisplayState display_state;
     display_state.display = snapshot;
     cached_displays.push_back(display_state);
   }
 
+  // Add virtual display if activated
+  if (configurator_->virtual_display_mode_.get()) {

[achuithb, 2015/02/11 23:41:44]

if (IsVirtualDisplayEnabled()) easier to read?

+    DisplayState display_state;
+    display_state.display = new DisplaySnapshotVirtual(
+        snapshots.size(), configurator_->virtual_display_mode_.get());
+    cached_displays.push_back(display_state);
+  }
+
   // Set |selected_mode| fields.
   for (size_t i = 0; i < cached_displays.size(); ++i) {
     DisplayState* display_state = &cached_displays[i];
     gfx::Size size;
     if (GetStateController() &&
         GetStateController()->GetResolutionForDisplayId(
             display_state->display->display_id(), &size)) {
       display_state->selected_mode =
           FindDisplayModeMatchingSize(*display_state->display, size);
     }
@@ skipping 432 matching lines @@
           HDCPState new_state =
               new_desired ? HDCP_STATE_DESIRED : HDCP_STATE_UNDESIRED;
           if (!native_display_delegate_->SetHDCPState(*it->display, new_state))
             return false;
         }
         break;
       }
       case DISPLAY_CONNECTION_TYPE_INTERNAL:
       case DISPLAY_CONNECTION_TYPE_VGA:
       case DISPLAY_CONNECTION_TYPE_NETWORK:
+      case DISPLAY_CONNECTION_TYPE_VIRTUAL:
         // No protections for these types. Do nothing.
         break;
       case DISPLAY_CONNECTION_TYPE_NONE:
         NOTREACHED();
         break;
     }
   }
 
   return true;
 }
@@ skipping 56 matching lines @@
           return false;
         if (state == HDCP_STATE_ENABLED)
           enabled |= CONTENT_PROTECTION_METHOD_HDCP;
         else
           unfulfilled |= CONTENT_PROTECTION_METHOD_HDCP;
         break;
       }
       case DISPLAY_CONNECTION_TYPE_INTERNAL:
       case DISPLAY_CONNECTION_TYPE_VGA:
       case DISPLAY_CONNECTION_TYPE_NETWORK:
+      case DISPLAY_CONNECTION_TYPE_VIRTUAL:
         // No protections for these types. Do nothing.
         break;
       case DISPLAY_CONNECTION_TYPE_NONE:
         NOTREACHED();
         break;
     }
   }
 
   // Don't reveal protections requested by other clients.
   ProtectionRequests::iterator it = client_protection_requests_.find(client_id);
@@ skipping 46 matching lines @@
 
   return true;
 }
 
 std::vector<ui::ColorCalibrationProfile>
 DisplayConfigurator::GetAvailableColorCalibrationProfiles(int64_t display_id) {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableDisplayColorCalibration)) {
     for (size_t i = 0; i < cached_displays_.size(); ++i) {
       if (cached_displays_[i].display &&
-          cached_displays_[i].display->display_id() == display_id) {
+          cached_displays_[i].display->display_id() == display_id &&
+          IsNativeDisplay(cached_displays_[i].display->type())) {
         return native_display_delegate_->GetAvailableColorCalibrationProfiles(
             *cached_displays_[i].display);
       }
     }
   }
 
   return std::vector<ui::ColorCalibrationProfile>();
 }
 
 bool DisplayConfigurator::SetColorCalibrationProfile(
     int64_t display_id,
     ui::ColorCalibrationProfile new_profile) {
   for (size_t i = 0; i < cached_displays_.size(); ++i) {
     if (cached_displays_[i].display &&
-        cached_displays_[i].display->display_id() == display_id) {
+        cached_displays_[i].display->display_id() == display_id &&
+        IsNativeDisplay(cached_displays_[i].display->type())) {
       return native_display_delegate_->SetColorCalibrationProfile(
           *cached_displays_[i].display, new_profile);
     }
   }
 
   return false;
 }
 
 void DisplayConfigurator::PrepareForExit() {
   configure_display_ = false;
@@ skipping 236 matching lines @@
     MultipleDisplayState attempted_state) {
   if (success) {
     FOR_EACH_OBSERVER(
         Observer, observers_, OnDisplayModeChanged(cached_displays_));
   } else {
     FOR_EACH_OBSERVER(
         Observer, observers_, OnDisplayModeChangeFailed(attempted_state));
   }
 }
 
+void DisplayConfigurator::EnableVirtualDisplay(
+    scoped_ptr<DisplayMode> display_mode) {
+  if (!virtual_display_enabled()) {
+    virtual_display_mode_ = display_mode.Pass();
+    ConfigureDisplays();
+  } else {
+    LOG(WARNING)

[achuithb, 2015/02/11 23:41:44]

NOTREACHED may be better here

+        << "Attempt to enable virtual display when it is already configured";
+  }
+}
+
+void DisplayConfigurator::DisableVirtualDisplay() {
+  if (virtual_display_enabled()) {
+    virtual_display_mode_.reset();
+    ConfigureDisplays();
+  } else {
+    LOG(WARNING) << "Attempt to disable virtual display when it is not enabled";

[achuithb, 2015/02/11 23:41:44]

NOTREACHED might be better here

+  }
+}
+
+int64 DisplayConfigurator::GetVirtualDisplayId(void) {

[achuithb, 2015/02/11 23:41:44]

don't need void

+  for (size_t i = 0; i < cached_displays_.size(); i++) {

[achuithb, 2015/02/11 23:41:44]

++i

+    if (cached_displays_[i].display->type() == DISPLAY_CONNECTION_TYPE_VIRTUAL)
+      return cached_displays_[i].display->display_id();
+  }
+  return gfx::Display::kInvalidDisplayID;
+}
 }  // namespace ui