Add support for virtual displays

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/apply_content_protection_task.h"
 #include "ui/display/chromeos/display_layout_manager.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/display/util/display_util.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;
 
 // The delay spent before reading the display configuration after coming out of
 // suspend. While coming out of suspend the display state may be updating. This
 // is used to wait until the hardware had a chance to update the display state
 // such that we read an up to date state.
 const int kResumeDelayMs = 500;
 
+// The EDID specification marks the top bit of the manufacturer id as reserved.
+const int16_t kReservedManufacturerID = 1 << 15;
+
 struct DisplayState {
   DisplaySnapshot* display = nullptr;  // Not owned.
 
   // User-selected mode for the display.
   const DisplayMode* selected_mode = nullptr;
 
   // Mode used when displaying the same desktop on multiple displays.
   const DisplayMode* mirror_mode = nullptr;
 };
 
@@ skipping 607 matching lines @@
   enable_protection_callbacks_.pop();
 
   if (!content_protection_tasks_.empty())
     content_protection_tasks_.front().Run();
 }
 
 void DisplayConfigurator::QueryContentProtectionStatus(
     ContentProtectionClientId client_id,
     int64_t display_id,
     const QueryProtectionCallback& callback) {
+  // Exclude virtual displays so that protected content will not be recaptured
+  // through the cast stream.
+  for (const DisplaySnapshot* display : cached_displays_) {
+    if (display->display_id() == display_id &&
+        !IsPhysicalDisplayType(display->type())) {
+      callback.Run(QueryProtectionResponse());
+      return;
+    }
+  }
+
   if (!configure_display_ || display_externally_controlled_) {
     callback.Run(QueryProtectionResponse());
     return;
   }
 
   query_protection_callbacks_.push(callback);
   QueryContentProtectionTask* task = new QueryContentProtectionTask(
       layout_manager_.get(), native_display_delegate_.get(), display_id,
       base::Bind(&DisplayConfigurator::OnContentProtectionQueried,
                  weak_ptr_factory_.GetWeakPtr(), client_id, display_id));
@@ skipping 98 matching lines @@
   callback.Run(true);
   if (!content_protection_tasks_.empty())
     content_protection_tasks_.front().Run();
 }
 
 std::vector<ui::ColorCalibrationProfile>
 DisplayConfigurator::GetAvailableColorCalibrationProfiles(int64_t display_id) {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableDisplayColorCalibration)) {
     for (const DisplaySnapshot* display : cached_displays_) {
-      if (display->display_id() == display_id) {
+      if (display->display_id() == display_id &&
+          IsPhysicalDisplayType(display->type())) {
         return native_display_delegate_->GetAvailableColorCalibrationProfiles(
             *display);
       }
     }
   }
 
   return std::vector<ui::ColorCalibrationProfile>();
 }
 
 bool DisplayConfigurator::SetColorCalibrationProfile(
     int64_t display_id,
     ui::ColorCalibrationProfile new_profile) {
   for (const DisplaySnapshot* display : cached_displays_) {
-    if (display->display_id() == display_id) {
+    if (display->display_id() == display_id &&
+        IsPhysicalDisplayType(display->type())) {
       return native_display_delegate_->SetColorCalibrationProfile(*display,
                                                                   new_profile);
     }
   }
 
   return false;
 }
 
 bool DisplayConfigurator::SetGammaRamp(
     int64_t display_id,
@@ skipping 150 matching lines @@
                   " requested";
     CallAndClearQueuedCallbacks(true);
     return;
   }
 
   configuration_task_.reset(new UpdateDisplayConfigurationTask(
       native_display_delegate_.get(), layout_manager_.get(),
       requested_display_state_, requested_power_state_, requested_power_flags_,
       0, force_configure_, base::Bind(&DisplayConfigurator::OnConfigured,
                                       weak_ptr_factory_.GetWeakPtr())));
+  configuration_task_->set_virtual_display_snapshots(
+      virtual_display_snapshots_.get());
 
   // Reset the flags before running the task; otherwise it may end up scheduling
   // another configuration.
   force_configure_ = false;
   requested_power_flags_ = kSetDisplayPowerNoFlags;
   requested_power_state_change_ = false;
   requested_display_state_ = MULTIPLE_DISPLAY_STATE_INVALID;
 
   DCHECK(in_progress_configuration_callbacks_.empty());
   in_progress_configuration_callbacks_.swap(queued_configuration_callbacks_);
@@ skipping 95 matching lines @@
   if (success) {
     FOR_EACH_OBSERVER(
         Observer, observers_, OnDisplayModeChanged(cached_displays_));
   } else {
     FOR_EACH_OBSERVER(
         Observer, observers_, OnDisplayModeChangeFailed(cached_displays_,
                                                         attempted_state));
   }
 }
 
+int64_t DisplayConfigurator::AddVirtualDisplay(gfx::Size display_size) {
+  if (last_virtual_display_id_ == 0xff) {
+    LOG(WARNING) << "Exceeded virtual display id limit";
+    return gfx::Display::kInvalidDisplayID;
+  }
+
+  DisplaySnapshotVirtual* virtual_snapshot =
+      new DisplaySnapshotVirtual(GenerateDisplayID(kReservedManufacturerID, 0x0,
+                                                   ++last_virtual_display_id_),
+                                 display_size);
+  virtual_display_snapshots_.push_back(virtual_snapshot);
+  ConfigureDisplays();
+
+  return virtual_snapshot->display_id();
+}
+
+bool DisplayConfigurator::RemoveVirtualDisplay(int64_t display_id) {
+  bool display_found = false;
+  for (auto it = virtual_display_snapshots_.begin();
+       it != virtual_display_snapshots_.end(); ++it) {
+    if ((*it)->display_id() == display_id) {
+      virtual_display_snapshots_.erase(it);
+      ConfigureDisplays();
+      display_found = true;
+      break;
+    }
+  }
+
+  if (!display_found)
+    return false;
+
+  int64_t highest_virtual_display_id = 0;
+  for (const auto& display : virtual_display_snapshots_) {
+    if (display->display_id() > highest_virtual_display_id)
+      highest_virtual_display_id = display->display_id();

[oshima, 2015/12/03 18:54:07]

optional: std::max if it fits in the single line (and nuke {})

+  }
+  last_virtual_display_id_ = highest_virtual_display_id & 0xff;
+
+  return true;
+}
+
 }  // namespace ui