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 14 matching lines @@
       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) {
   ProcessRemovedDisplays(displays);
   ProcessModifiedDisplays(displays);
+
+  // If the primary display is marked as removed we'll try to find a new primary
+  // display and update the delegate before removing the old primary display.
+  if (primary_display_id_ == Display::kInvalidDisplayID) {
+    for (const DisplayInfo& display : cached_displays_) {
+      if (!display.removed) {
+        primary_display_id_ = display.id;
+        delegate_->OnPrimaryDisplayChanged(primary_display_id_);
+        break;
+      }
+    }
+  }
+
   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