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 "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 145 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_ = service_manager::Connector::Create(&connector_request);

[jonross, 2017/03/16 23:59:16]

You should not be trying to create a new Connector here. This is an asynchronous
process.

Since we expect the display code to be ran in both classic ash, along within the
window server, you should rely on the preexisting Connector for the process.
Have both places which instantiate this pass in the Connector for their process.

Then use that to connect to the preferences service.

[thanhph, 2017/03/17 19:11:43]

Thanks! I use connector() in window_manager and pass |connector| to this Init()
as an argument.

+  connector_->BindInterface(prefs::mojom::kPrefStoreServiceName,
+                            &pref_factory_ptr);
+  pref_client_store_ =
+      new preferences::PrefClientStore(std::move(pref_factory_ptr));
+
+  pref_client_store_->Subscribe({prefs::kDisplayRotationLock});
+  pref_client_store_->Subscribe({prefs::kSecondaryDisplays});
+  pref_client_store_->Subscribe({prefs::kDisplayProperties});
+  pref_client_store_->Subscribe({prefs::kDisplayPowerState});

[jonross, 2017/03/16 23:59:16]

These should be enqueued in a vector and only one call to subscribe

[thanhph, 2017/03/17 19:11:43]

Done.

+
+  pref_client_store_->AddObserver(this);

[jonross, 2017/03/16 23:59:16]

This should be done before subscribing.

See the example code in:
https://codereview.chromium.org/2474653003/diff/280001/ash/common/shelf/shelf...

[thanhph, 2017/03/17 19:11:43]

Thanks! I realize preferences::PrefObserverStore no longer exists though.

[jonross, 2017/03/17 19:18:34]

PrefObserverStore was renamed PrefClientStore

+
+  //  if (pref_client_store_->IsInitializationComplete()) {
+  //    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 194 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