Work In Progess

services/ui/display/screen_manager_ozone_internal.cc

 // Copyright 2016 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_ozone_internal.h"
 
 #include <string>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "chrome/common/pref_names.h"
 #include "chromeos/system/devicemode.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/service_manager/public/cpp/interface_registry.h"
 #include "services/ui/display/output_protection.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/display/manager/chromeos/display_change_observer.h"
 #include "ui/display/manager/chromeos/touch_transform_controller.h"
 #include "ui/display/manager/display_layout_store.h"
 #include "ui/display/manager/display_manager_utilities.h"
 #include "ui/display/screen.h"
 #include "ui/display/screen_base.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/display/types/fake_display_controller.h"
 #include "ui/display/types/native_display_delegate.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/ozone/public/ozone_platform.h"
 
+#include "ui/display/manager/display_preferences.h"
+
+#include "services/service_manager/public/cpp/connector.h"
+
+#include "components/prefs/pref_store.h"
+#include "services/preferences/public/interfaces/preferences.mojom.h"
+
+#include "base/values.h"
+
 namespace display {
 namespace {
 
 // Needed for DisplayConfigurator::ForceInitialConfigure.
 const SkColor kChromeOsBootColor = SkColorSetRGB(0xfe, 0xfe, 0xfe);
 
 // Recursively swaps the displays in a DisplayLayout to change the primary
 // display but keep the same relative display layout.
 // TODO(kylechar): This is copied from WindowTreeHostManager. The concept of
 // getting the same relative display layout with a different primary display id
@@ skipping 102 matching lines @@
   delegate_->OnPrimaryDisplayChanged(primary_display_id_);
 }
 
 void ScreenManagerOzoneInternal::AddInterfaces(
     service_manager::InterfaceRegistry* registry) {
   registry->AddInterface<mojom::DisplayController>(this);
   registry->AddInterface<mojom::OutputProtection>(this);
   registry->AddInterface<mojom::TestDisplayController>(this);
 }
 
-void ScreenManagerOzoneInternal::Init(ScreenManagerDelegate* delegate) {
+void ScreenManagerOzoneInternal::Init(ScreenManagerDelegate* delegate,
+                                      service_manager::Connector* connector) {
   DCHECK(delegate);
   delegate_ = delegate;
 
   // Tests may inject a NativeDisplayDelegate, otherwise get it from
   // OzonePlatform.
   if (!native_display_delegate_) {
     native_display_delegate_ =
         ui::OzonePlatform::GetInstance()->CreateNativeDisplayDelegate();
   }
 
@@ skipping 22 matching lines @@
   display_configurator_.AddObserver(display_change_observer_.get());
   display_configurator_.set_state_controller(display_change_observer_.get());
   display_configurator_.set_mirroring_controller(display_manager_.get());
 
   // Perform initial configuration.
   display_configurator_.Init(std::move(native_display_delegate_), false);
   display_configurator_.ForceInitialConfigure(kChromeOsBootColor);
 
   touch_transform_controller_ = base::MakeUnique<TouchTransformController>(
       &display_configurator_, display_manager_.get());
+
+  // base::Value pref_kDisplayRotationLock(prefs::kDisplayRotationLock);
+  // base::Value pref_kSecondaryDisplays(prefs::kSecondaryDisplays);
+  // base::Value pref_kDisplayProperties(prefs::kDisplayProperties);
+  // base::Value pref_kDisplayPowerState(prefs::kDisplayPowerState);
+
+  // auto prefs = base::MakeUnique<base::DictionaryValue>();
+
+  // prefs->Set(prefs::kDisplayRotationLock,
+  // pref_kDisplayRotationLock.CreateDeepCopy());
+  // prefs->Set(prefs::kSecondaryDisplays,
+  // pref_kSecondaryDisplays.CreateDeepCopy());
+  // prefs->Set(prefs::kDisplayProperties,
+  // pref_kDisplayProperties.CreateDeepCopy());
+  // prefs->Set(prefs::kDisplayPowerState,
+  // pref_kDisplayPowerState.CreateDeepCopy());
+
+  connector_ = connector;
+  connector_->BindInterface(prefs::mojom::kServiceName, &pref_factory_ptr);
+  pref_client_store_ =
+      new preferences::PrefClientStore(std::move(pref_factory_ptr));
+
+  pref_client_store_->AddObserver(this);
+
+  //display::LoadDisplayPreferences(true, &display_configurator_,
+  //display_manager_.get(), pref_client_store_.get());
+
+  pref_client_store_->Subscribe(
+      {prefs::kDisplayRotationLock, prefs::kSecondaryDisplays,
+       prefs::kDisplayProperties, prefs::kDisplayProperties});
+
+  // if (pref_client_store_->IsInitializationComplete()) {
+  // LOG(ERROR) << "display::ScreenManagerOzoneInternal::Init() 6";
+  // OnInitializationCompleted(true);
+  //}
+  //  OnPrefValueChanged(prefs::kDisplayRotationLock);
+  //  OnPrefValueChanged(prefs::kSecondaryDisplays);
+  //  OnPrefValueChanged(prefs::kDisplayProperties);
+  //  OnPrefValueChanged(prefs::kDisplayPowerState);
+}
+
+void ScreenManagerOzoneInternal::OnInitializationCompleted(bool succeeded) {
+  DCHECK(!initialization_completed_);
+  DCHECK(succeeded);
+  DCHECK(pref_client_store_->IsInitializationComplete());
+  initialization_completed_ = true;
+
+  LOG(ERROR)
+      << "OnInitializationCompleted true----------------------------------";
+  pref_client_store_->SetValue(prefs::kDisplayRotationLock,
+                               base::MakeUnique<base::Value>(10), 1);
+  //   LOG(ERROR) << "--------
+  //   pref_client_store_->GetValue(prefs::kDisplayRotationLock):" << temp;
+  //  display::LoadDisplayPreferences(true, &display_configurator_,
+  //  display_manager_.get(), pref_client_store_.get());
+}
+
+void ScreenManagerOzoneInternal::OnPrefValueChanged(const std::string& key) {
+  const base::Value* value = NULL;
+  DCHECK(pref_client_store_->GetValue(key, &value));
+  LOG(ERROR) << "-------- ScreenManagerOzoneInternal::OnPrefValueChanged: "
+             << value;
+  changed_prefs_.Set(key, value->DeepCopy());
 }
 
 void ScreenManagerOzoneInternal::RequestCloseDisplay(int64_t display_id) {
   if (!fake_display_controller_)
     return;
 
   // Tell the NDD to remove the display. ScreenManager will get an update
   // that the display configuration has changed and the display will be gone.
   fake_display_controller_->RemoveDisplay(display_id);
 }
@@ skipping 192 matching lines @@
       std::move(request));
 }
 
 void ScreenManagerOzoneInternal::Create(
     const service_manager::Identity& remote_identity,
     mojom::TestDisplayControllerRequest request) {
   test_bindings_.AddBinding(this, std::move(request));
 }
 
 }  // namespace display