Use mojo Shelf interfaces for both mash and classic ash.

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/mus/shelf_delegate_mus.h"
-
-#include <memory>
+#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/shelf_model.h"
-#include "ash/common/shelf/shelf_widget.h"
 #include "ash/common/shelf/wm_shelf.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 "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 {
 
-// A ShelfItemDelegate used for pinned items.
-// TODO(mash): Support open user windows, etc.
+// A ShelfItemDelegate used for pinned items in mash.
+// TODO(mash): Support open windows, cooperate with ShelfWindowWatcher.
 class ShelfItemDelegateMus : public ShelfItemDelegate {
  public:
   ShelfItemDelegateMus() {}
   ~ShelfItemDelegateMus() override {}
 
   void SetDelegate(mojom::ShelfItemDelegateAssociatedPtrInfo delegate) {
     delegate_.Bind(std::move(delegate));
   }
 
   bool pinned() const { return pinned_; }
@@ skipping 87 matching lines @@
   void Close() override { NOTIMPLEMENTED(); }
 
   mojom::ShelfItemDelegateAssociatedPtr delegate_;
   bool pinned_ = false;
   std::map<uint32_t, base::string16> window_id_to_title_;
   base::string16 title_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfItemDelegateMus);
 };
 
+// Returns the ShelfItemDelegateMus instance for the given |shelf_id|.
 ShelfItemDelegateMus* GetShelfItemDelegate(ShelfID shelf_id) {
   return static_cast<ShelfItemDelegateMus*>(
       WmShell::Get()->shelf_model()->GetShelfItemDelegate(shelf_id));
 }
 
-// Returns an icon image from an SkBitmap, or the default shelf icon
-// image if the bitmap is empty. Assumes the bitmap is a 1x icon.
+// Returns an icon image from an SkBitmap, or the default shelf icon image if
+// the bitmap is empty. Assumes the bitmap is a 1x icon.
 // TODO(jamescook): Support other scale factors.
 gfx::ImageSkia GetShelfIconFromBitmap(const SkBitmap& bitmap) {
   gfx::ImageSkia icon_image;
   if (!bitmap.isNull()) {
     icon_image = gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
   } else {
     // Use default icon.
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     icon_image = *rb.GetImageSkiaNamed(IDR_DEFAULT_FAVICON);
   }
   return icon_image;
 }
 
+// Returns the WmShelf instance for the display with the given |display_id|.
+WmShelf* GetShelfForDisplay(int64_t display_id) {
+  // 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
 
-ShelfDelegateMus::ShelfDelegateMus(ShelfModel* model) : model_(model) {}
+ShelfController::ShelfController() {}
 
-ShelfDelegateMus::~ShelfDelegateMus() {}
+ShelfController::~ShelfController() {}
 
-///////////////////////////////////////////////////////////////////////////////
-// ShelfDelegate:
+void ShelfController::BindRequest(mojom::ShelfControllerRequest request) {
+  bindings_.AddBinding(this, std::move(request));
+}
 
-void ShelfDelegateMus::OnShelfCreated(WmShelf* shelf) {
+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 ShelfDelegateMus::OnShelfDestroyed(WmShelf* shelf) {}
-
-void ShelfDelegateMus::OnShelfAlignmentChanged(WmShelf* shelf) {
+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 ShelfDelegateMus::OnShelfAutoHideBehaviorChanged(WmShelf* shelf) {
+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);
   });
 }
 
-void ShelfDelegateMus::OnShelfAutoHideStateChanged(WmShelf* shelf) {}
-
-void ShelfDelegateMus::OnShelfVisibilityStateChanged(WmShelf* shelf) {}

[sky, 2016/10/07 16:10:17]

How come OnShelfAutoHideStateChanged and OnShelfVisibilityStateChanged are no
longer needed?

[msw, 2016/10/07 22:45:57]

All implementations are empty / no-op, ditto for OnShelfDestroyed:
  https://cs.chromium.org/search/?q=OnShelfAutoHideStateChanged
  https://cs.chromium.org/search/?q=OnShelfVisibilityStateChanged
  https://cs.chromium.org/search/?q=OnShelfDestroyed
They can be added back later if they're ever needed.

-
-ShelfID ShelfDelegateMus::GetShelfIDForAppID(const std::string& app_id) {
-  if (app_id_to_shelf_id_.count(app_id))
-    return app_id_to_shelf_id_[app_id];
-  return 0;
-}
-
-ShelfID ShelfDelegateMus::GetShelfIDForAppIDAndLaunchID(
-    const std::string& app_id,
-    const std::string& launch_id) {
-  return ShelfDelegateMus::GetShelfIDForAppID(app_id);
-}
-
-bool ShelfDelegateMus::HasShelfIDToAppIDMapping(ShelfID id) const {
-  return shelf_id_to_app_id_.count(id) != 0;
-}
-
-const std::string& ShelfDelegateMus::GetAppIDForShelfID(ShelfID id) {
-  if (shelf_id_to_app_id_.count(id))
-    return shelf_id_to_app_id_[id];
-  return base::EmptyString();
-}
-
-void ShelfDelegateMus::PinAppWithID(const std::string& app_id) {
-  NOTIMPLEMENTED();
-}
-
-bool ShelfDelegateMus::IsAppPinned(const std::string& app_id) {
-  NOTIMPLEMENTED();
-  return false;
-}
-
-void ShelfDelegateMus::UnpinAppWithID(const std::string& app_id) {
-  NOTIMPLEMENTED();
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// mojom::ShelfController:
-
-void ShelfDelegateMus::AddObserver(
+void ShelfController::AddObserver(
     mojom::ShelfObserverAssociatedPtrInfo observer) {
   mojom::ShelfObserverAssociatedPtr observer_ptr;
   observer_ptr.Bind(std::move(observer));
-  // Notify the observer of the current state.
-  for (const auto& display : display::Screen::GetScreen()->GetAllDisplays()) {
-    WmWindow* root = WmShell::Get()->GetRootWindowForDisplayId(display.id());
-    WmShelf* shelf = root->GetRootWindowController()->GetShelf();
-    observer_ptr->OnAlignmentChanged(shelf->alignment(), display.id());
-    observer_ptr->OnAutoHideBehaviorChanged(shelf->auto_hide_behavior(),
-                                            display.id());
-  }
   observers_.AddPtr(std::move(observer_ptr));
 }
 
-void ShelfDelegateMus::SetAlignment(ShelfAlignment alignment,
-                                    int64_t display_id) {
-  WmRootWindowController* root_window_controller =
-      WmLookup::Get()->GetRootWindowControllerWithDisplayId(display_id);
-  // The controller may be null for invalid ids or for displays being removed.
-  if (root_window_controller && root_window_controller->HasShelf())
-    root_window_controller->GetShelf()->SetAlignment(alignment);
+void ShelfController::SetAlignment(ShelfAlignment alignment,
+                                   int64_t display_id) {
+  if (!ash::WmShelf::ShelfAlignmentAllowed())
+    return;
+
+  WmShelf* shelf = GetShelfForDisplay(display_id);
+  // TODO(jamescook): The initialization check should not be necessary, but
+  // otherwise this wrongly tries to set the alignment on a secondary display
+  // during login before the ShelfLockingManager and ShelfView are created.
+  if (shelf && shelf->IsShelfInitialized())
+    shelf->SetAlignment(alignment);
 }
 
-void ShelfDelegateMus::SetAutoHideBehavior(ShelfAutoHideBehavior auto_hide,
-                                           int64_t display_id) {
-  WmRootWindowController* root_window_controller =
-      WmLookup::Get()->GetRootWindowControllerWithDisplayId(display_id);
-  // The controller may be null for invalid ids or for displays being removed.
-  if (root_window_controller && root_window_controller->HasShelf())
-    root_window_controller->GetShelf()->SetAutoHideBehavior(auto_hide);
+void ShelfController::SetAutoHideBehavior(ShelfAutoHideBehavior auto_hide,
+                                          int64_t display_id) {
+  WmShelf* shelf = GetShelfForDisplay(display_id);
+  // TODO(jamescook): The initialization check should not be necessary, but
+  // otherwise this wrongly tries to set auto-hide state on a secondary display
+  // during login before the ShelfView is created.
+  if (shelf && shelf->IsShelfInitialized())
+    shelf->SetAutoHideBehavior(auto_hide);
 }
 
-void ShelfDelegateMus::PinItem(
+void ShelfController::PinItem(
     mojom::ShelfItemPtr item,
     mojom::ShelfItemDelegateAssociatedPtrInfo delegate) {
   if (app_id_to_shelf_id_.count(item->app_id)) {
     ShelfID shelf_id = app_id_to_shelf_id_[item->app_id];
     ShelfItemDelegateMus* item_delegate = GetShelfItemDelegate(shelf_id);
     item_delegate->SetDelegate(std::move(delegate));
     item_delegate->set_pinned(true);
     return;
   }
 
-  ShelfID shelf_id = model_->next_id();
+  ShelfID shelf_id = model_.next_id();
   app_id_to_shelf_id_.insert(std::make_pair(item->app_id, shelf_id));
   shelf_id_to_app_id_.insert(std::make_pair(shelf_id, item->app_id));
 
   ShelfItem shelf_item;
   shelf_item.type = TYPE_APP_SHORTCUT;
   shelf_item.status = STATUS_CLOSED;
   shelf_item.image = GetShelfIconFromBitmap(item->image);
-  model_->Add(shelf_item);
+  model_.Add(shelf_item);
 
   std::unique_ptr<ShelfItemDelegateMus> item_delegate(
       new ShelfItemDelegateMus());
   item_delegate->SetDelegate(std::move(delegate));
   item_delegate->set_pinned(true);
   item_delegate->set_title(base::UTF8ToUTF16(item->app_title));
-  model_->SetShelfItemDelegate(shelf_id, std::move(item_delegate));
+  model_.SetShelfItemDelegate(shelf_id, std::move(item_delegate));
 }
 
-void ShelfDelegateMus::UnpinItem(const std::string& app_id) {
+void ShelfController::UnpinItem(const std::string& app_id) {
   if (!app_id_to_shelf_id_.count(app_id))
     return;
+
   ShelfID shelf_id = app_id_to_shelf_id_[app_id];
   ShelfItemDelegateMus* item_delegate = GetShelfItemDelegate(shelf_id);
   DCHECK(item_delegate->pinned());
   item_delegate->set_pinned(false);
   if (item_delegate->window_id_to_title().empty()) {
-    model_->RemoveItemAt(model_->ItemIndexByID(shelf_id));
+    model_.RemoveItemAt(model_.ItemIndexByID(shelf_id));
     app_id_to_shelf_id_.erase(app_id);
     shelf_id_to_app_id_.erase(shelf_id);
   }
 }
 
-void ShelfDelegateMus::SetItemImage(const std::string& app_id,
-                                    const SkBitmap& image) {
+void ShelfController::SetItemImage(const std::string& app_id,
+                                   const SkBitmap& image) {
   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);
+  int index = model_.ItemIndexByID(shelf_id);
   DCHECK_GE(index, 0);
-  ShelfItem item = *model_->ItemByID(shelf_id);
+  ShelfItem item = *model_.ItemByID(shelf_id);
   item.image = GetShelfIconFromBitmap(image);
-  model_->Set(index, item);
+  model_.Set(index, item);
 }
 
 }  // namespace ash