Primary display change notifications.

services/ui/display/platform_screen_ozone.cc

 // Copyright 2016 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 "services/ui/display/platform_screen_ozone.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 146 matching lines @@
     }
   }
 
   // Set next display index as primary, or loop back to first display if last.
   if (primary_display_index + 1 == num_displays) {
     primary_display_id_ = cached_displays_[0].id;
   } else {
     primary_display_id_ = cached_displays_[primary_display_index + 1].id;
   }
 
-  // TODO(kylechar): Update ws::DisplayManager.
+  delegate_->OnPrimaryDisplayChanged(primary_display_id_);
 }
 
 void PlatformScreenOzone::SetDisplayWorkArea(int64_t display_id,
                                              const gfx::Size& size,
                                              const gfx::Insets& insets) {
   CachedDisplayIterator iter = GetCachedDisplayIterator(display_id);
   if (iter == cached_displays_.end()) {
     NOTREACHED() << display_id;
     return;
   }
@@ skipping 25 matching lines @@
 
   // Find cached displays with no matching snapshot and mark as removed.
   for (DisplayInfo& display : cached_displays_) {
     if (std::find(current_ids.begin(), current_ids.end(), display.id) ==
         current_ids.end()) {
       display.removed = true;
       if (primary_display_id_ == display.id)
         primary_display_id_ = Display::kInvalidDisplayID;
     }
   }
-
-  // If the primary display was removed find a new primary display id.
-  if (primary_display_id_ == Display::kInvalidDisplayID) {
-    for (const DisplayInfo& display : cached_displays_) {
-      if (!display.removed) {
-        primary_display_id_ = display.id;
-        break;
-      }
-    }
-  }
 }
 
 void PlatformScreenOzone::ProcessModifiedDisplays(
     const ui::DisplayConfigurator::DisplayStateList& snapshots) {
   for (ui::DisplaySnapshot* snapshot : snapshots) {
     auto iter = GetCachedDisplayIterator(snapshot->display_id());
     if (iter != cached_displays_.end()) {
       DisplayInfo& display_info = *iter;
       ViewportMetrics new_metrics =
           MetricsFromSnapshot(*snapshot, display_info.metrics.bounds.origin());
@@ skipping 39 matching lines @@
 
 void PlatformScreenOzone::AddNewDisplays(
     const ui::DisplayConfigurator::DisplayStateList& snapshots) {
   for (ui::DisplaySnapshot* snapshot : snapshots) {
     const int64_t id = snapshot->display_id();
 
     // Check if display already exists and skip.
     if (GetCachedDisplayIterator(id) != cached_displays_.end())
       continue;
 
-    // If we have no primary display then this one should be it.
-    if (primary_display_id_ == Display::kInvalidDisplayID)
-      primary_display_id_ = id;
-
     DisplayInfo display_info;
     display_info.id = snapshot->display_id();
     display_info.metrics = MetricsFromSnapshot(*snapshot, next_display_origin_);
 
     // Store the display mode sizes so we can toggle through them.
     for (auto& mode : snapshot->modes()) {
       display_info.supported_sizes.push_back(mode->size());
       if (mode.get() == snapshot->current_mode())
         display_info.requested_size = mode->size();
     }
 
     // Move the origin so that next display is to the right of current display.
     next_display_origin_.Offset(display_info.metrics.bounds.width(), 0);
 
     cached_displays_.push_back(display_info);
     delegate_->OnDisplayAdded(display_info.id, display_info.metrics);
+
+    // If we have no primary display then this one should be it.
+    if (primary_display_id_ == Display::kInvalidDisplayID) {
+      primary_display_id_ = id;
+      delegate_->OnPrimaryDisplayChanged(primary_display_id_);
+    }
   }
 }
 
 PlatformScreenOzone::CachedDisplayIterator
 PlatformScreenOzone::GetCachedDisplayIterator(int64_t display_id) {
   return std::find_if(cached_displays_.begin(), cached_displays_.end(),
                       [display_id](const DisplayInfo& display_info) {
                         return display_info.id == display_id;
                       });
 }
@@ skipping 12 matching lines @@
   // ui scale factor is always 1.0 here for now.
   gfx::Size scaled_size = gfx::ScaleToRoundedSize(
       current_mode->size(), 1.0f / metrics.device_scale_factor);
   metrics.bounds = gfx::Rect(origin, scaled_size);
   metrics.work_area = metrics.bounds;
   return metrics;
 }
 
 void PlatformScreenOzone::OnDisplayModeChanged(
     const ui::DisplayConfigurator::DisplayStateList& displays) {
+  int64_t old_primary_display_id = primary_display_id_;
+
   ProcessRemovedDisplays(displays);
   ProcessModifiedDisplays(displays);
+
+  // If the primary display was removed try to find a new primary display.
+  if (primary_display_id_ == Display::kInvalidDisplayID) {
+    for (const DisplayInfo& display : cached_displays_) {

[sky, 2016/10/28 17:08:47]

Do you need to handle the case of no more displays here? That is, should this
set primary_display_id_ to invalid before the for loop?

[kylechar, 2016/10/28 19:40:36]

That's handled when the last primary display is marked removed,
primary_display_id_ will have been set to kInvalidDisplayID. If there is no
other displays it will stay as kInvalidDisplayID. 

I've changed this not to call OnPrimaryDisplayChanged() for kInvalidDisplayID
though as per your other comments.

+      if (!display.removed) {
+        primary_display_id_ = display.id;
+        break;
+      }
+    }
+  }
+
+  if (old_primary_display_id != primary_display_id_)
+    delegate_->OnPrimaryDisplayChanged(primary_display_id_);
+
   UpdateCachedDisplays();
   AddNewDisplays(displays);
+
   wait_for_display_config_update_ = false;
 }
 
 void PlatformScreenOzone::OnDisplayModeChangeFailed(
     const ui::DisplayConfigurator::DisplayStateList& displays,
     ui::MultipleDisplayState failed_new_state) {
   LOG(ERROR) << "OnDisplayModeChangeFailed from DisplayConfigurator";
   wait_for_display_config_update_ = false;
 }
 
@@ skipping 22 matching lines @@
   return false;
 }
 
 void PlatformScreenOzone::Create(
     const service_manager::Identity& remote_identity,
     mojom::TestDisplayControllerRequest request) {
   test_bindings_.AddBinding(this, std::move(request));
 }
 
 }  // namespace display