Add Mojo NativeDisplayDelegate / NativeDisplayObserver.

services/ui/display/screen_manager_forwarding.cc

Index: services/ui/display/screen_manager_forwarding.cc
diff --git a/services/ui/display/screen_manager_forwarding.cc b/services/ui/display/screen_manager_forwarding.cc
new file mode 100644
index 0000000000000000000000000000000000000000..10d73c75ed06198d9f7cc7eea835a9bfc8e1576e
--- /dev/null
+++ b/services/ui/display/screen_manager_forwarding.cc
@@ -0,0 +1,203 @@
+// 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/interface_registry.h"
+#include "ui/display/types/display_constants.h"
+#include "ui/display/types/display_snapshot_mojo.h"
+#include "ui/display/types/native_display_delegate.h"
+#include "ui/ozone/public/ozone_platform.h"
+
+namespace display {
+namespace {
+
+// Finds the display mode in |snapshot| that corresponds to |mode_to_find|.
+const DisplayMode* GetCorrespondingMode(const DisplaySnapshot& snapshot,
+                                        const DisplayMode* mode_to_find) {
+  if (!mode_to_find)
+    return nullptr;
+
+  for (auto& mode : snapshot.modes()) {
+    if (mode->size() == mode_to_find->size() &&
+        mode->is_interlaced() == mode_to_find->is_interlaced() &&
+        mode->refresh_rate() == mode_to_find->refresh_rate()) {
+      return mode.get();
+    }
+  }
+  NOTREACHED();
+  return nullptr;
+}
+
+}  // namespace
+
+// TODO(sky/kylechar): Change ScreenManager::Create() to make a
+// ScreenManagerForwarding in mus mode.''
+
+ScreenManagerForwarding::ScreenManagerForwarding()
+    : binding_(this), weak_ptr_factory_(this) {}
+
+ScreenManagerForwarding::~ScreenManagerForwarding() {
+  if (native_display_delegate_)
+    native_display_delegate_->RemoveObserver(this);
+}
+
+void ScreenManagerForwarding::AddInterfaces(
+    service_manager::InterfaceRegistry* registry) {
+  registry->AddInterface<mojom::NativeDisplayDelegate>(this);
+}
+
+void ScreenManagerForwarding::Init(ScreenManagerDelegate* delegate) {
+  // Done in NativeDisplayDelegate::Initialize() instead.
+}
+
+void ScreenManagerForwarding::RequestCloseDisplay(int64_t display_id) {}
+
+void ScreenManagerForwarding::OnConfigurationChanged() {
+  if (observer_.is_bound())
+    observer_->OnConfigurationChanged();
+}
+
+void ScreenManagerForwarding::OnDisplaySnapshotsInvalidated() {
+  snapshot_map_.clear();
+}
+
+void ScreenManagerForwarding::RegisterObserver(
+    mojom::NativeDisplayObserverPtr observer) {
+  observer_ = std::move(observer);
+}
+
+void ScreenManagerForwarding::Initialize() {
+  DCHECK(!native_display_delegate_);
+  native_display_delegate_ =
+      ui::OzonePlatform::GetInstance()->CreateNativeDisplayDelegate();
+  native_display_delegate_->AddObserver(this);
+  native_display_delegate_->Initialize();
+}
+
+void ScreenManagerForwarding::TakeDisplayControl(
+    const TakeDisplayControlCallback& callback) {
+  DCHECK(native_display_delegate_);
+  native_display_delegate_->TakeDisplayControl(callback);
+}
+
+void ScreenManagerForwarding::RelinquishDisplayControl(
+    const RelinquishDisplayControlCallback& callback) {
+  DCHECK(native_display_delegate_);
+  native_display_delegate_->RelinquishDisplayControl(callback);
+}
+
+void ScreenManagerForwarding::GetDisplays(const GetDisplaysCallback& callback) {
+  DCHECK(native_display_delegate_);
+  native_display_delegate_->GetDisplays(
+      base::Bind(&ScreenManagerForwarding::ForwardGetDisplays,
+                 weak_ptr_factory_.GetWeakPtr(), callback));

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

Similar comment here about not needing a weak_ptr_factory_.

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

Done.

+}
+
+void ScreenManagerForwarding::Configure(
+    int64_t display_id,
+    std::unique_ptr<display::DisplayMode> mode,
+    const gfx::Point& origin,
+    const ConfigureCallback& callback) {
+  DCHECK(native_display_delegate_);
+  DisplaySnapshot* snapshot = snapshot_map_[display_id];
+  if (!snapshot) {
+    callback.Run(false);
+    return;
+  }
+
+  // We need a pointer to the mode in |snapshot|, not the equivalent mode we
+  // received over Mojo.
+  const DisplayMode* snapshot_mode =
+      GetCorrespondingMode(*snapshot, mode.get());
+  native_display_delegate_->Configure(
+      *snapshot, snapshot_mode, origin,
+      base::Bind(&ScreenManagerForwarding::ForwardConfigure,
+                 weak_ptr_factory_.GetWeakPtr(), snapshot, snapshot_mode,
+                 origin, callback));
+}
+
+void ScreenManagerForwarding::GetHDCPState(
+    int64_t display_id,
+    const GetHDCPStateCallback& callback) {
+  DCHECK(native_display_delegate_);
+  const DisplaySnapshot* snapshot = snapshot_map_[display_id];
+  if (!snapshot) {
+    callback.Run(false, HDCP_STATE_UNDESIRED);
+    return;
+  }
+
+  native_display_delegate_->GetHDCPState(*snapshot, callback);
+}
+
+void ScreenManagerForwarding::SetHDCPState(
+    int64_t display_id,
+    display::HDCPState state,
+    const SetHDCPStateCallback& callback) {
+  DCHECK(native_display_delegate_);
+  const DisplaySnapshot* snapshot = snapshot_map_[display_id];
+  if (!snapshot) {
+    callback.Run(false);
+    return;
+  }
+
+  native_display_delegate_->SetHDCPState(*snapshot, state, callback);
+}
+
+void ScreenManagerForwarding::SetColorCorrection(
+    int64_t display_id,
+    const std::vector<display::GammaRampRGBEntry>& degamma_lut,
+    const std::vector<display::GammaRampRGBEntry>& gamma_lut,
+    const std::vector<float>& correction_matrix) {
+  DCHECK(native_display_delegate_);
+  const DisplaySnapshot* snapshot = snapshot_map_[display_id];
+  if (!snapshot)
+    return;
+
+  native_display_delegate_->SetColorCorrection(*snapshot, degamma_lut,
+                                               gamma_lut, correction_matrix);
+}
+
+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 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));
+  }
+
+  callback.Run(std::move(mojo_snapshots));
+}
+
+void ScreenManagerForwarding::ForwardConfigure(
+    DisplaySnapshot* snapshot,
+    const DisplayMode* mode,
+    const gfx::Point& origin,
+    const mojom::NativeDisplayDelegate::ConfigureCallback& callback,
+    bool status) {
+  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