PreferencesManager

ash/common/shelf/shelf_controller.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 "ash/common/shelf/shelf_controller.h"
 
 #include "ash/common/shelf/shelf_item_delegate.h"
 #include "ash/common/shelf/shelf_menu_model.h"
 #include "ash/common/shelf/wm_shelf.h"
+#include "ash/common/shell_delegate.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "base/strings/utf_string_conversions.h"
+#include "services/preferences/public/cpp/pref_observer_store.h"
+#include "services/preferences/public/interfaces/preferences.mojom.h"
+#include "services/service_manager/public/cpp/connector.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/resources/grit/ui_resources.h"
 
 namespace ash {
 
 namespace {
 
@@ skipping 132 matching lines @@
   // The controller may be null for invalid ids or for displays being removed.
   WmRootWindowController* root_window_controller =
       WmLookup::Get()->GetRootWindowControllerWithDisplayId(display_id);
   return root_window_controller ? root_window_controller->GetShelf() : nullptr;
 }
 
 }  // namespace
 
 ShelfController::ShelfController() {}
 
-ShelfController::~ShelfController() {}
+ShelfController::~ShelfController() {
+  if (store_)
+    store_->RemoveObserver(this);
+}
 
 void ShelfController::BindRequest(mojom::ShelfControllerRequest request) {
   bindings_.AddBinding(this, std::move(request));
+
+  // Sample of connecting to the PreferencesManager
+  WmShell* shell = WmShell::Get();
+  service_manager::Connector* connector =
+      shell->delegate()->GetShellConnector();
+  if (!connector)
+    return;
+  prefs::mojom::PreferencesManagerPtr pref_manager_ptr;
+  connector->ConnectToInterface("service:content_browser", &pref_manager_ptr);
+  store_ = new PrefObserverStore(std::move(pref_manager_ptr));
+  std::set<std::string> keys;
+  // chrome::common::pref_names::kShelfAutoHideBehavior
+  const std::string key("auto_hide_behavior");
+  keys.insert(key);

[James Cook, 2016/11/15 20:27:17]

Drive-by: I wonder if we should have a single pref_manager or pref_service
controller hanging off of WmShell. In particular, it might be nice to have a
single place where we build the list of all prefs that ash cares about, so we
can subscribe to all of them in one IPC.

We could also do something where each individual controller class (like this
one) in its constructor registers the prefs it cares about with
WmShell/pref_manager, then WmShell subscribes to them all at the end of
initialization.

Thanks for working on this, btw, it'll simplify some of the stuff I have to do
for SystemTrayDelegate.

[jonross, 2016/11/15 22:49:44]

We could make a single exit point from Ash. To reduce the size of the
subscription IPC.

As is right now each component in ash could add itself as a PrefStore::Observer,
but that would become quite noisy in process as the current observer model sends
notifications for any change in the store.

We could do:
1) Create a prefs::mojom::PreferenceObserver that manages the connection. Which
would create small PrefStores for each component in Ash that wants to listen.
2) Update PrefObserverStore::AddObserver to require a set of keys, and do the
filtering of notifications there.

+  store_->AddObserver(this);
+  store_->Init(keys);
 }
 
 void ShelfController::NotifyShelfCreated(WmShelf* shelf) {
   // Notify observers, Chrome will set alignment and auto-hide from prefs.
   int64_t display_id = shelf->GetWindow()->GetDisplayNearestWindow().id();
   observers_.ForAllPtrs([display_id](mojom::ShelfObserver* observer) {
     observer->OnShelfCreated(display_id);
   });
 }
 
 void ShelfController::NotifyShelfAlignmentChanged(WmShelf* shelf) {
   ShelfAlignment alignment = shelf->alignment();
   int64_t display_id = shelf->GetWindow()->GetDisplayNearestWindow().id();
   observers_.ForAllPtrs(
       [alignment, display_id](mojom::ShelfObserver* observer) {
         observer->OnAlignmentChanged(alignment, display_id);
       });
 }
 
 void ShelfController::NotifyShelfAutoHideBehaviorChanged(WmShelf* shelf) {
   ShelfAutoHideBehavior behavior = shelf->auto_hide_behavior();
   int64_t display_id = shelf->GetWindow()->GetDisplayNearestWindow().id();
   observers_.ForAllPtrs([behavior, display_id](mojom::ShelfObserver* observer) {
     observer->OnAutoHideBehaviorChanged(behavior, display_id);
   });
+
+  // Using Preferences to set the value. the chrome ShelfObserver can seprately
+  // listen to preference changes to make any according UI state changes.
+  std::string behaviour_pref;
+  switch (behavior) {
+    case SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS:
+      behaviour_pref = "Always";
+      break;
+    case SHELF_AUTO_HIDE_BEHAVIOR_NEVER:
+      behaviour_pref = "Never";
+      break;
+    default:
+      behaviour_pref = "ooops";
+  }
+  std::unique_ptr<base::Value> value(new base::StringValue(behaviour_pref));
+  if (store_)
+    store_->SetValue("auto_hide_behavior", std::move(value), 0);
 }
 
 void ShelfController::AddObserver(
     mojom::ShelfObserverAssociatedPtrInfo observer) {
   mojom::ShelfObserverAssociatedPtr observer_ptr;
   observer_ptr.Bind(std::move(observer));
   observers_.AddPtr(std::move(observer_ptr));
 }
 
 void ShelfController::SetAlignment(ShelfAlignment alignment,
@@ skipping 68 matching lines @@
   if (!app_id_to_shelf_id_.count(app_id))
     return;
   ShelfID shelf_id = app_id_to_shelf_id_[app_id];
   int index = model_.ItemIndexByID(shelf_id);
   DCHECK_GE(index, 0);
   ShelfItem item = *model_.ItemByID(shelf_id);
   item.image = GetShelfIconFromBitmap(image);
   model_.Set(index, item);
 }
 
+void ShelfController::OnPrefValueChanged(const std::string& key) {
+  const base::Value* value = nullptr;
+  store_->GetValue("auto_hide_behavior", &value);
+  if (!value)
+    return;
+  std::string actual_value;
+  value->GetAsString(&actual_value);
+  LOG(ERROR) << "JR OnPrefValueChanged " << key << " : " << actual_value
+             << "\n";
+
+  // Call a method that needs the pref here
+}
+
+void ShelfController::OnInitializationCompleted(bool succeeded) {
+  LOG(ERROR) << "JR OnInitializationCompleted\n";
+  if (!succeeded)
+    return;
+  const base::Value* value = nullptr;
+  store_->GetValue("auto_hide_behavior", &value);
+  if (!value)
+    return;
+  std::string actual_value;
+  value->GetAsString(&actual_value);
+  LOG(ERROR) << "\tJR auto_hide_behavior: " << actual_value << "\n";
+
+  // Call a method that needs the pref here
+}
+
 }  // namespace ash