Make ForwardingDisplayDelegate initially sync.

services/ui/display/screen_manager_forwarding.cc

 // Copyright 2017 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/screen_manager_forwarding.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "services/service_manager/public/cpp/binder_registry.h"
@@ skipping 51 matching lines @@
 void ScreenManagerForwarding::OnConfigurationChanged() {
   if (observer_.is_bound())
     observer_->OnConfigurationChanged();
 }
 
 void ScreenManagerForwarding::OnDisplaySnapshotsInvalidated() {
   snapshot_map_.clear();
 }
 
 void ScreenManagerForwarding::Initialize(
-    mojom::NativeDisplayObserverPtr observer) {
+    mojom::NativeDisplayObserverPtr observer,
+    const InitializeCallback& callback) {
   DCHECK(!native_display_delegate_);
   observer_ = std::move(observer);
 
   native_display_delegate_ =
       ui::OzonePlatform::GetInstance()->CreateNativeDisplayDelegate();
   native_display_delegate_->AddObserver(this);
   native_display_delegate_->Initialize();
+
+  // Provide the list of display snapshots initially. ForwardingDisplayDelegate
+  // will wait synchronously for this.
+  native_display_delegate_->GetDisplays(
+      base::Bind(&ScreenManagerForwarding::ForwardGetDisplays,
+                 base::Unretained(this), callback));
+
+  // When ForwardingDisplayDelegate receives this it will start asynchronous
+  // operation and redo any configuration that was skipped.
+  observer_->OnConfigurationChanged();
 }
 
 void ScreenManagerForwarding::TakeDisplayControl(
     const TakeDisplayControlCallback& callback) {
   DCHECK(native_display_delegate_);
   native_display_delegate_->TakeDisplayControl(callback);
 }
 
 void ScreenManagerForwarding::RelinquishDisplayControl(
     const RelinquishDisplayControlCallback& callback) {
@@ skipping 73 matching lines @@
 }
 
 void ScreenManagerForwarding::Create(
     const service_manager::Identity& remote_identity,
     mojom::NativeDisplayDelegateRequest request) {
   DCHECK(!binding_.is_bound());
   binding_.Bind(std::move(request));
 }
 
 void ScreenManagerForwarding::ForwardGetDisplays(
-    const mojom::NativeDisplayDelegate::GetDisplaysCallback& callback,
+    const GetDisplaysCallback& callback,
     const std::vector<DisplaySnapshot*>& snapshots) {
   snapshot_map_.clear();
 
   // Convert the DisplaySnapshots to MojoDisplaySnapshots to allow sending
   // over Mojo. Also caches the snapshots for lookup later.
   std::vector<std::unique_ptr<DisplaySnapshotMojo>> mojo_snapshots;
   for (auto* snapshot : snapshots) {
     snapshot_map_[snapshot->display_id()] = snapshot;
     mojo_snapshots.push_back(DisplaySnapshotMojo::CreateFrom(*snapshot));
   }
@@ skipping 10 matching lines @@
   if (status) {
     // Modify display snapshot similar to how ConfigureDisplaysTask would. Ozone
     // DRM needs these to be changed and ConfigureDisplaysTasks can't do it.
     snapshot->set_current_mode(mode);
     snapshot->set_origin(origin);
   }
   callback.Run(status);
 }
 
 }  // namespace display