Make ForwardingDisplayDelegate initially sync.

ui/display/manager/forwarding_display_delegate.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 "ui/display/manager/forwarding_display_delegate.h"
 
 #include <utility>
 
 #include "base/bind.h"
+#include "mojo/public/cpp/bindings/sync_call_restrictions.h"
 #include "ui/display/types/display_snapshot_mojo.h"
 
 namespace display {
 
 ForwardingDisplayDelegate::ForwardingDisplayDelegate(
     mojom::NativeDisplayDelegatePtr delegate)
     : delegate_(std::move(delegate)), binding_(this) {}
 
 ForwardingDisplayDelegate::~ForwardingDisplayDelegate() {}
 
 void ForwardingDisplayDelegate::Initialize() {
-  delegate_->Initialize(binding_.CreateInterfacePtrAndBind());
+  // TODO(kylechar/sky): Figure out how to make this not synchronous.
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall scoped_sync;
+
+  // This is a synchronous call to Initialize() because ash depends on
+  // NativeDisplayDelegate being synchronous during it's initialization. Calls
+  // to GetDisplays() and Configure() will return early starting now using
+  // whatever is in |snapshots_|.
+  delegate_->Initialize(binding_.CreateInterfacePtrAndBind(), &snapshots_);
 }
 
 void ForwardingDisplayDelegate::GrabServer() {}
 
 void ForwardingDisplayDelegate::UngrabServer() {}
 
 void ForwardingDisplayDelegate::TakeDisplayControl(
     const DisplayControlCallback& callback) {
   delegate_->TakeDisplayControl(callback);
 }
 
 void ForwardingDisplayDelegate::RelinquishDisplayControl(
     const DisplayControlCallback& callback) {
   delegate_->TakeDisplayControl(callback);
 }
 
 void ForwardingDisplayDelegate::SyncWithServer() {}
 
 void ForwardingDisplayDelegate::SetBackgroundColor(uint32_t color_argb) {}
 
 void ForwardingDisplayDelegate::ForceDPMSOn() {}
 
 void ForwardingDisplayDelegate::GetDisplays(
     const GetDisplaysCallback& callback) {
+  if (!use_delegate_) {
+    ForwardDisplays(callback);
+    return;
+  }
+
   delegate_->GetDisplays(
       base::Bind(&ForwardingDisplayDelegate::StoreAndForwardDisplays,
                  base::Unretained(this), callback));
 }
 
 void ForwardingDisplayDelegate::AddMode(const DisplaySnapshot& snapshot,
                                         const DisplayMode* mode) {}
 
 void ForwardingDisplayDelegate::Configure(const DisplaySnapshot& snapshot,
                                           const DisplayMode* mode,
                                           const gfx::Point& origin,
                                           const ConfigureCallback& callback) {
+  if (!use_delegate_) {
+    // Pretend configuration succeeded. When the first OnConfigurationChanged()
+    // is received this will run again and actually happen.
+    callback.Run(true);
+    return;
+  }
+
   delegate_->Configure(snapshot.display_id(), mode->Clone(), origin, callback);
 }
 
 void ForwardingDisplayDelegate::CreateFrameBuffer(const gfx::Size& size) {}
 
 void ForwardingDisplayDelegate::GetHDCPState(
     const DisplaySnapshot& snapshot,
     const GetHDCPStateCallback& callback) {
   delegate_->GetHDCPState(snapshot.display_id(), callback);
 }
@@ skipping 36 matching lines @@
 void ForwardingDisplayDelegate::RemoveObserver(
     display::NativeDisplayObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 FakeDisplayController* ForwardingDisplayDelegate::GetFakeDisplayController() {
   return nullptr;
 }
 
 void ForwardingDisplayDelegate::OnConfigurationChanged() {
+  // Start asynchronous operation once the first OnConfigurationChanged()
+  // arrives. We know |delegate_| is usable at this point.
+  use_delegate_ = true;
+
   // Forward OnConfigurationChanged received over Mojo to local observers.
   for (auto& observer : observers_)
     observer.OnConfigurationChanged();
 }
 
 void ForwardingDisplayDelegate::StoreAndForwardDisplays(
     const GetDisplaysCallback& callback,
     std::vector<std::unique_ptr<DisplaySnapshotMojo>> snapshots) {
   for (auto& observer : observers_)
     observer.OnDisplaySnapshotsInvalidated();
   snapshots_ = std::move(snapshots);
 
+  ForwardDisplays(callback);
+}
+
+void ForwardingDisplayDelegate::ForwardDisplays(
+    const GetDisplaysCallback& callback) {
   std::vector<DisplaySnapshot*> snapshot_ptrs;
   for (auto& snapshot : snapshots_)
     snapshot_ptrs.push_back(snapshot.get());
   callback.Run(snapshot_ptrs);
 }
 
 }  // namespace display