Add Mojo NativeDisplayDelegate / NativeDisplayObserver.

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 "ui/display/types/display_snapshot_mojo.h"
+
+namespace display {
+
+ForwardingDisplayDelegate::ForwardingDisplayDelegate()
+    : binding_(this), weak_ptr_factory_(this) {}
+
+ForwardingDisplayDelegate::~ForwardingDisplayDelegate() {}
+
+void ForwardingDisplayDelegate::Connect(
+    mojom::NativeDisplayDelegatePtr delegate) {
+  delegate_ = std::move(delegate);
+  delegate_->RegisterObserver(binding_.CreateInterfacePtrAndBind());
+}
+
+void ForwardingDisplayDelegate::Initialize() {
+  delegate_->Initialize();
+}
+
+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) {
+  delegate_->GetDisplays(
+      base::Bind(&ForwardingDisplayDelegate::StoreAndForwardDisplays,
+                 weak_ptr_factory_.GetWeakPtr(), callback));

[sky, 2017/04/06 20:30:20]

As delegate_ is owned by this class you shouldn't need the weak_ptr_factory_
here. Instead use base::Unretained.

[kylechar, 2017/04/07 13:52:16]

Done.

+}
+
+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) {
+  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);
+}
+
+void ForwardingDisplayDelegate::SetHDCPState(
+    const DisplaySnapshot& snapshot,
+    HDCPState state,
+    const SetHDCPStateCallback& callback) {
+  delegate_->SetHDCPState(snapshot.display_id(), state, callback);
+}
+
+std::vector<ColorCalibrationProfile>
+ForwardingDisplayDelegate::GetAvailableColorCalibrationProfiles(
+    const DisplaySnapshot& output) {
+  return std::vector<ColorCalibrationProfile>();
+}
+
+bool ForwardingDisplayDelegate::SetColorCalibrationProfile(
+    const DisplaySnapshot& output,
+    ColorCalibrationProfile new_profile) {
+  return false;
+}
+
+bool ForwardingDisplayDelegate::SetColorCorrection(
+    const DisplaySnapshot& output,
+    const std::vector<GammaRampRGBEntry>& degamma_lut,
+    const std::vector<GammaRampRGBEntry>& gamma_lut,
+    const std::vector<float>& correction_matrix) {
+  delegate_->SetColorCorrection(output.display_id(), degamma_lut, gamma_lut,
+                                correction_matrix);
+  // DrmNativeDisplayDelegate always returns true so this will too.
+  return true;
+}
+
+void ForwardingDisplayDelegate::AddObserver(
+    display::NativeDisplayObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void ForwardingDisplayDelegate::RemoveObserver(
+    display::NativeDisplayObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+FakeDisplayController* ForwardingDisplayDelegate::GetFakeDisplayController() {
+  return nullptr;
+}
+
+void ForwardingDisplayDelegate::OnConfigurationChanged() {
+  // 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);

[sky, 2017/04/06 20:30:21]

AFACIT you never use these. Is it worth caching them? Should GetDisplays() use
the cached version under some conditions?

[kylechar, 2017/04/07 13:52:16]

Since this is the NDD implementation it needs to own the snapshots.
DisplaySnapshot*s eventually make their way back to DisplayConfigurator via a
series of callbacks. I think that UpdateDisplaysTask, DisplayChangeObserver and
DisplayConfigurator all use those pointers.

Also, the GetDisplays() method is kind of badly named. The results are cached in
DisplayConfigurator already. GetDisplays() is mostly called when we actually
want to refresh the set of displays because something has changed.

I updated the comment on |snapshots_|.

+
+  std::vector<DisplaySnapshot*> snapshot_ptrs;
+  for (auto& snapshot : snapshots_)
+    snapshot_ptrs.push_back(snapshot.get());
+  callback.Run(snapshot_ptrs);
+}
+
+}  // namespace display