Allow ForwardingDelegate to have a null delegate

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(
     mojom::NativeDisplayDelegatePtr delegate)
     : delegate_(std::move(delegate)), binding_(this) {}
 
 ForwardingDisplayDelegate::~ForwardingDisplayDelegate() {}
 
 void ForwardingDisplayDelegate::Initialize() {
-  delegate_->Initialize(binding_.CreateInterfacePtrAndBind());
+  if (delegate_)
+    delegate_->Initialize(binding_.CreateInterfacePtrAndBind());
 }
 
 void ForwardingDisplayDelegate::GrabServer() {}
 
 void ForwardingDisplayDelegate::UngrabServer() {}
 
 void ForwardingDisplayDelegate::TakeDisplayControl(
     const DisplayControlCallback& callback) {
-  delegate_->TakeDisplayControl(callback);
+  if (delegate_)
+    delegate_->TakeDisplayControl(callback);
 }
 
 void ForwardingDisplayDelegate::RelinquishDisplayControl(
     const DisplayControlCallback& callback) {
-  delegate_->TakeDisplayControl(callback);
+  if (delegate_)
+    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,
-                 base::Unretained(this), callback));
+  if (delegate_) {
+    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) {
-  delegate_->Configure(snapshot.display_id(), mode->Clone(), origin, callback);
+  if (delegate_)
+    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);
+  if (delegate_)
+    delegate_->GetHDCPState(snapshot.display_id(), callback);
 }
 
 void ForwardingDisplayDelegate::SetHDCPState(
     const DisplaySnapshot& snapshot,
     HDCPState state,
     const SetHDCPStateCallback& callback) {
-  delegate_->SetHDCPState(snapshot.display_id(), state, callback);
+  if (delegate_)
+    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);
+  if (delegate_) {
+    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(
@@ skipping 18 matching lines @@
     observer.OnDisplaySnapshotsInvalidated();
   snapshots_ = std::move(snapshots);
 
   std::vector<DisplaySnapshot*> snapshot_ptrs;
   for (auto& snapshot : snapshots_)
     snapshot_ptrs.push_back(snapshot.get());
   callback.Run(snapshot_ptrs);
 }
 
 }  // namespace display