mash: Support ShelfModel access in Chrome.

chrome/browser/ui/ash/launcher/chrome_launcher_controller.cc

 // Copyright 2013 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 "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 
 #include "ash/multi_profile_uma.h"
+#include "ash/public/cpp/remote_shelf_item_delegate.h"
 #include "ash/public/cpp/shelf_item.h"
 #include "ash/public/interfaces/constants.mojom.h"
 #include "ash/resources/grit/ash_resources.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shell.h"
 #include "ash/shell_port.h"
 #include "ash/strings/grit/ash_strings.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/wm_window.h"
@@ skipping 158 matching lines @@
       chrome::MultiUserWindowManager::MULTI_PROFILE_MODE_SEPARATED)
     chrome::MultiUserWindowManager::GetInstance()->AddUser(profile);
   controller_->AdditionalUserAddedToSession(profile->GetOriginalProfile());
 }
 
 // static
 ChromeLauncherController* ChromeLauncherController::instance_ = nullptr;
 
 ChromeLauncherController::ChromeLauncherController(Profile* profile,
                                                    ash::ShelfModel* model)
-    : model_(model), observer_binding_(this), weak_ptr_factory_(this) {
+    : model_(model),
+      observer_binding_(this),
+      shelf_model_observer_binding_(this),
+      weak_ptr_factory_(this) {
   DCHECK(!instance_);
   instance_ = this;
 
   DCHECK(model_);
 
   if (!profile) {
     // If no profile was passed, we take the currently active profile and use it
     // as the owner of the current desktop.
     // Use the original profile as on chromeos we may get a temporary off the
     // record profile, unless in guest session (where off the record profile is
@@ skipping 76 matching lines @@
   if (instance_ == this)
     instance_ = nullptr;
 }
 
 void ChromeLauncherController::Init() {
   // Start observing the shelf controller.
   if (ConnectToShelfController()) {
     ash::mojom::ShelfObserverAssociatedPtrInfo ptr_info;
     observer_binding_.Bind(mojo::MakeRequest(&ptr_info));
     shelf_controller_->AddObserver(std::move(ptr_info));
+    if (ash_util::IsRunningInMash()) {
+      // Mash synchronizes two ShelfModel instances, owned by Ash and Chrome.
+      // Delay binding Chrome's observer of Ash for now, to avoid handling Ash's
+      // shelf model changes before the initial states have been synchronized.
+      ash::mojom::ShelfModelObserverPtr observer_ptr;
+      shelf_model_observer_request_ = mojo::MakeRequest(&observer_ptr);
+      shelf_controller_->LinkShelfModels(
+          std::move(observer_ptr),
+          base::Bind(&ChromeLauncherController::LinkShelfModels,
+                     weak_ptr_factory_.GetWeakPtr()));
+    }
   }
 
   CreateBrowserShortcutLauncherItem();
   UpdateAppLaunchersFromPref();
 
   // TODO(sky): update unit test so that this test isn't necessary.
   if (ash::Shell::HasInstance())
     SetVirtualKeyboardBehaviorFromPrefs();
 
   prefs_observer_ = ChromeLauncherPrefsObserver::CreateIfNecessary(profile());
@@ skipping 937 matching lines @@
   pref_change_registrar_.RemoveAll();
 
   app_list::AppListSyncableService* app_service =
       app_list::AppListSyncableServiceFactory::GetForProfile(profile());
   if (app_service)
     app_service->RemoveObserver(this);
 
   PrefServiceSyncableFromProfile(profile())->RemoveObserver(this);
 }
 
+void ChromeLauncherController::LinkShelfModels(
+    ash::mojom::ShelfModelObserverPtr observer,
+    const std::vector<ash::ShelfItem>& items) {
+  // Prepend Ash's shelf model items to the local (Chrome) shelf model.
+  DCHECK(!applying_remote_shelf_model_changes_) << "Unexpected model change";
+  base::AutoReset<bool> reset(&applying_remote_shelf_model_changes_, true);
+  for (size_t i = 0; i < items.size(); ++i)
+    model_->AddAt(i, items[i]);
+
+  // Notify Ash of all the other existing local (Chrome) items and delegates.
+  for (int32_t i = items.size(); i < model_->item_count(); ++i) {
+    const ash::ShelfItem& item = model_->items()[i];
+    observer->OnShelfItemAdded(i, item);
+    ash::ShelfItemDelegate* delegate = model_->GetShelfItemDelegate(item.id);
+    observer->OnShelfItemDelegateChanged(
+        item.id, delegate ? delegate->CreateInterfacePtrAndBind()
+                          : ash::mojom::ShelfItemDelegatePtr());
+  }
+
+  // Delay binding Chrome's observer of Ash until now, to avoid handling Ash's
+  // shelf model changes before the initial states have been synchronized.
+  shelf_model_observer_binding_.Bind(std::move(shelf_model_observer_request_));
+  shelf_model_observers_.AddPtr(std::move(observer));
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // ash::mojom::ShelfObserver:
 
 void ChromeLauncherController::OnShelfInitialized(int64_t display_id) {
   if (!ConnectToShelfController())
     return;
 
   // The pref helper functions return default values for invalid display ids.
   PrefService* prefs = profile_->GetPrefs();
   shelf_controller_->SetAlignment(GetShelfAlignmentPref(prefs, display_id),
@@ skipping 16 matching lines @@
 void ChromeLauncherController::OnAutoHideBehaviorChanged(
     ash::ShelfAutoHideBehavior auto_hide,
     int64_t display_id) {
   DCHECK(!updating_shelf_pref_from_observer_);
   base::AutoReset<bool> updating(&updating_shelf_pref_from_observer_, true);
   // This will uselessly store a preference value for invalid display ids.
   SetShelfAutoHideBehaviorPref(profile_->GetPrefs(), display_id, auto_hide);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// ash::mojom::ShelfModelObserver:
+
+void ChromeLauncherController::OnShelfItemAdded(int32_t index,
+                                                const ash::ShelfItem& item) {
+  DCHECK(ash_util::IsRunningInMash()) << "Unexpected model synchronization";
+  DCHECK(!applying_remote_shelf_model_changes_) << "Unexpected model change";
+  DCHECK_GE(model_->item_count(), index) << "Models out of sync";
+  base::AutoReset<bool> reset(&applying_remote_shelf_model_changes_, true);
+  model_->AddAt(index, item);
+}
+
+void ChromeLauncherController::OnShelfItemRemoved(int32_t index,
+                                                  const ash::ShelfItem& item) {
+  DCHECK(ash_util::IsRunningInMash()) << "Unexpected model synchronization";
+  DCHECK(!applying_remote_shelf_model_changes_) << "Unexpected model change";
+  DCHECK_GT(model_->item_count(), index) << "Models out of sync";
+  DCHECK_EQ(model_->items()[index].id, item.id) << "Models out of sync";
+  base::AutoReset<bool> reset(&applying_remote_shelf_model_changes_, true);
+  model_->RemoveItemAt(index);
+}
+
+void ChromeLauncherController::OnShelfItemMoved(int32_t start_index,
+                                                int32_t target_index) {
+  DCHECK(ash_util::IsRunningInMash()) << "Unexpected model synchronization";
+  DCHECK(!applying_remote_shelf_model_changes_) << "Unexpected model change";
+  DCHECK_GT(model_->item_count(), start_index) << "Models out of sync";
+  DCHECK_GT(model_->item_count(), target_index) << "Models out of sync";
+  base::AutoReset<bool> reset(&applying_remote_shelf_model_changes_, true);
+  model_->Move(start_index, target_index);
+}
+
+void ChromeLauncherController::OnShelfItemChanged(int32_t index,
+                                                  const ash::ShelfItem& item) {
+  DCHECK(ash_util::IsRunningInMash()) << "Unexpected model synchronization";
+  DCHECK(!applying_remote_shelf_model_changes_) << "Unexpected model change";
+  DCHECK_GT(model_->item_count(), index) << "Models out of sync";
+  DCHECK_EQ(model_->items()[index].id, item.id) << "Models out of sync";
+  base::AutoReset<bool> reset(&applying_remote_shelf_model_changes_, true);
+  model_->Set(index, item);
+}
+
+void ChromeLauncherController::OnShelfItemDelegateChanged(
+    const ash::ShelfID& id,
+    ash::mojom::ShelfItemDelegatePtr delegate) {
+  DCHECK(ash_util::IsRunningInMash()) << "Unexpected model synchronization";
+  DCHECK(!applying_remote_shelf_model_changes_) << "Unexpected model change";
+  base::AutoReset<bool> reset(&applying_remote_shelf_model_changes_, true);
+  if (delegate.is_bound())
+    model_->SetShelfItemDelegate(id,
+                                 base::MakeUnique<ash::RemoteShelfItemDelegate>(
+                                     id, std::move(delegate)));
+  else
+    model_->SetShelfItemDelegate(id, nullptr);
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // ash::ShelfModelObserver:
 
 void ChromeLauncherController::ShelfItemAdded(int index) {
+  ash::ShelfItem item = model_->items()[index];
+  if (!applying_remote_shelf_model_changes_) {
+    shelf_model_observers_.ForAllPtrs(
+        [index, item](ash::mojom::ShelfModelObserver* observer) {
+          observer->OnShelfItemAdded(index, item);
+        });
+  }
+
   // Update the pin position preference as needed.
-  ash::ShelfItem item = model_->items()[index];
   if (ItemTypeIsPinned(item) && should_sync_pin_changes_)
     SyncPinPosition(item.id);
 
   // Fetch and update the icon for the app's item.
   const std::string& app_id = item.id.app_id;
   AppIconLoader* app_icon_loader = GetAppIconLoaderForApp(app_id);
   if (app_icon_loader) {
     app_icon_loader->FetchImage(app_id);
     app_icon_loader->UpdateImage(app_id);
   }
 
   // Update the item with any missing Chrome-specific info.
   if (item.type == ash::TYPE_APP || item.type == ash::TYPE_PINNED_APP) {
     bool needs_update = false;
     if (item.image.isNull()) {
       needs_update = true;
       item.image = extensions::util::GetDefaultAppIcon();
     }
     if (item.title.empty()) {
       needs_update = true;
       item.title = LauncherControllerHelper::GetAppTitle(profile(), app_id);
     }
     ash::ShelfItemStatus status = GetAppState(app_id);
     if (status != item.status && status != ash::STATUS_CLOSED) {
       needs_update = true;
       item.status = status;
     }
-    if (needs_update)
+    if (needs_update) {
+      // Ensure these changes are reported back to Ash.
+      base::AutoReset<bool> reset(&applying_remote_shelf_model_changes_, false);
       model_->Set(index, item);
+    }
   }
 
   // Construct a ShelfItemDelegate for the item if one does not yet exist.
   if (!model_->GetShelfItemDelegate(item.id)) {
+    // Ensure these changes are reported back to Ash.
+    base::AutoReset<bool> reset(&applying_remote_shelf_model_changes_, false);
     model_->SetShelfItemDelegate(
         item.id, AppShortcutLauncherItemController::Create(item.id));
   }
 }
 
 void ChromeLauncherController::ShelfItemRemoved(
     int index,
     const ash::ShelfItem& old_item) {
+  if (!applying_remote_shelf_model_changes_) {
+    shelf_model_observers_.ForAllPtrs(
+        [index, old_item](ash::mojom::ShelfModelObserver* observer) {
+          observer->OnShelfItemRemoved(index, old_item);
+        });
+  }
+
   // Remove the pin position from preferences as needed.
   if (ItemTypeIsPinned(old_item) && should_sync_pin_changes_)
     RemovePinPosition(profile(), old_item.id);
 
   AppIconLoader* app_icon_loader = GetAppIconLoaderForApp(old_item.id.app_id);
   if (app_icon_loader)
     app_icon_loader->ClearImage(old_item.id.app_id);
 }
 
 void ChromeLauncherController::ShelfItemMoved(int start_index,
                                               int target_index) {
+  if (!applying_remote_shelf_model_changes_) {
+    shelf_model_observers_.ForAllPtrs(
+        [start_index, target_index](ash::mojom::ShelfModelObserver* observer) {
+          observer->OnShelfItemMoved(start_index, target_index);
+        });
+  }
+
   // Update the pin position preference as needed.
   const ash::ShelfItem& item = model_->items()[target_index];
   DCHECK_NE(ash::TYPE_APP_LIST, item.type);
   if (ItemTypeIsPinned(item) && should_sync_pin_changes_)
     SyncPinPosition(item.id);
 }
 
 void ChromeLauncherController::ShelfItemChanged(
     int index,
     const ash::ShelfItem& old_item) {
+  if (!applying_remote_shelf_model_changes_) {
+    const ash::ShelfItem& item = model_->items()[index];
+    shelf_model_observers_.ForAllPtrs(
+        [index, item](ash::mojom::ShelfModelObserver* observer) {
+          observer->OnShelfItemChanged(index, item);
+        });
+  }
+
   if (!should_sync_pin_changes_)
     return;
 
   const ash::ShelfItem& item = model_->items()[index];
   // Add or remove the pin position from preferences as needed.
   if (!ItemTypeIsPinned(old_item) && ItemTypeIsPinned(item))
     SyncPinPosition(item.id);
   else if (ItemTypeIsPinned(old_item) && !ItemTypeIsPinned(item))
     RemovePinPosition(profile(), old_item.id);
 }
 
+void ChromeLauncherController::ShelfItemDelegateChanged(
+    const ash::ShelfID& id,
+    ash::ShelfItemDelegate* delegate) {
+  if (applying_remote_shelf_model_changes_)
+    return;
+
+  shelf_model_observers_.ForAllPtrs(
+      [id, delegate](ash::mojom::ShelfModelObserver* observer) {
+        observer->OnShelfItemDelegateChanged(
+            id, delegate ? delegate->CreateInterfacePtrAndBind()
+                         : ash::mojom::ShelfItemDelegatePtr());
+      });
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // ash::WindowTreeHostManager::Observer:
 
 void ChromeLauncherController::OnDisplayConfigurationChanged() {
   // In BOTTOM_LOCKED state, ignore the call of SetShelfBehaviorsFromPrefs.
   // Because it might be called by some operations, like crbug.com/627040
   // rotating screen.
   ash::Shelf* shelf = ash::Shelf::ForWindow(ash::Shell::GetPrimaryRootWindow());
   if (shelf->alignment() != ash::SHELF_ALIGNMENT_BOTTOM_LOCKED)
     SetShelfBehaviorsFromPrefs();
@@ skipping 10 matching lines @@
           : IDS_ASH_SHELF_APP_LIST_LAUNCHER_TITLE);
 
   const int app_list_index = model_->GetItemIndexForType(ash::TYPE_APP_LIST);
   DCHECK_GE(app_list_index, 0);
   ash::ShelfItem item = model_->items()[app_list_index];
   if (item.title != title) {
     item.title = title;
     model_->Set(app_list_index, item);
   }
 }