mash: Disable ash_sysui; begin removal.

ash/sysui/shelf_delegate_mus.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/sysui/shelf_delegate_mus.h"
 
 #include <memory>
 
 #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_types.h"
 #include "ash/common/system/status_area_widget.h"
 #include "ash/common/wm_shell.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_widget.h"
 #include "base/strings/string_util.h"
 #include "mojo/common/common_type_converters.h"
 #include "services/shell/public/cpp/connector.h"
 #include "services/ui/public/cpp/property_type_converters.h"
 #include "services/ui/public/cpp/window.h"
 #include "services/ui/public/cpp/window_property.h"
 #include "ui/aura/mus/mus_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/resources/grit/ui_resources.h"
 #include "ui/views/mus/window_manager_connection.h"
 
-using ash::mojom::UserWindowController;
-
 namespace ash {
 namespace sysui {
 
 namespace {
 
-// A ShelfItemDelegate used for pinned items and open user windows.
+// A ShelfItemDelegate used for pinned items.
+// TODO(mash): Support open user windows, etc.
 class ShelfItemDelegateMus : public ShelfItemDelegate {
  public:
-  explicit ShelfItemDelegateMus(UserWindowController* user_window_controller)
-      : user_window_controller_(user_window_controller) {}
+  ShelfItemDelegateMus() {}
   ~ShelfItemDelegateMus() override {}
 
   void SetDelegate(
       mash::shelf::mojom::ShelfItemDelegateAssociatedPtrInfo delegate) {
     delegate_.Bind(std::move(delegate));
   }
 
   bool pinned() const { return pinned_; }
   void set_pinned(bool pinned) { pinned_ = pinned; }
 
@@ skipping 31 matching lines @@
 
     // ShelfMenuModel:
     bool IsCommandActive(int command_id) const override { return false; }
 
     // ui::SimpleMenuModel::Delegate:
     bool IsCommandIdChecked(int command_id) const override { return false; }
     bool IsCommandIdEnabled(int command_id) const override {
       return command_id > 0;
     }
     void ExecuteCommand(int command_id, int event_flags) override {
-      item_delegate_->user_window_controller_->ActivateUserWindow(command_id);
+      NOTIMPLEMENTED();
     }
 
    private:
     ShelfItemDelegateMus* item_delegate_;
 
     DISALLOW_COPY_AND_ASSIGN(ShelfMenuModelMus);
   };
 
   // ShelfItemDelegate:
   ShelfItemDelegate::PerformedAction ItemSelected(
       const ui::Event& event) override {
     if (window_id_to_title_.empty()) {
       delegate_->LaunchItem();
       return kNewWindowCreated;
     }
     if (window_id_to_title_.size() == 1) {
-      user_window_controller_->ActivateUserWindow(
-          window_id_to_title_.begin()->first);
-      return kExistingWindowActivated;
+      // TODO(mash): Activate the window and return kExistingWindowActivated.
+      NOTIMPLEMENTED();
     }
     return kNoAction;
   }
 
   base::string16 GetTitle() override {
     return window_id_to_title_.empty() ? title_
                                        : window_id_to_title_.begin()->second;
   }
 
   bool CanPin() const override {
@@ skipping 11 matching lines @@
   }
 
   bool ShouldShowTooltip() override { return true; }
 
   void Close() override { NOTIMPLEMENTED(); }
 
   mash::shelf::mojom::ShelfItemDelegateAssociatedPtr delegate_;
   bool pinned_ = false;
   std::map<uint32_t, base::string16> window_id_to_title_;
   base::string16 title_;
-  UserWindowController* user_window_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfItemDelegateMus);
 };
 
 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
@@ skipping 13 matching lines @@
 
 // Returns an icon image from a serialized SkBitmap.
 gfx::ImageSkia GetShelfIconFromSerializedBitmap(
     const mojo::Array<uint8_t>& serialized_bitmap) {
   SkBitmap bitmap = mojo::ConvertTo<SkBitmap>(serialized_bitmap.storage());
   return GetShelfIconFromBitmap(bitmap);
 }
 
 }  // namespace
 
-ShelfDelegateMus::ShelfDelegateMus(ShelfModel* model)
-    : model_(model), binding_(this) {
-  ::shell::Connector* connector =
-      views::WindowManagerConnection::Get()->connector();
-  connector->ConnectToInterface("mojo:ash", &shelf_layout_);
-  connector->ConnectToInterface("mojo:ash", &user_window_controller_);
-  user_window_controller_->AddUserWindowObserver(
-      binding_.CreateInterfacePtrAndBind());
-}
+ShelfDelegateMus::ShelfDelegateMus(ShelfModel* model) : model_(model) {}
 
 ShelfDelegateMus::~ShelfDelegateMus() {}
 
 ///////////////////////////////////////////////////////////////////////////////
 // ShelfDelegate:
 
 void ShelfDelegateMus::OnShelfCreated(Shelf* shelf) {
   SetShelfPreferredSizes(shelf);
 }
 
 void ShelfDelegateMus::OnShelfDestroyed(Shelf* shelf) {
   NOTIMPLEMENTED();
 }
 
 void ShelfDelegateMus::OnShelfAlignmentChanged(Shelf* shelf) {
   SetShelfPreferredSizes(shelf);
   mash::shelf::mojom::Alignment alignment =
       static_cast<mash::shelf::mojom::Alignment>(shelf->alignment());
-  shelf_layout_->SetAlignment(alignment);
-
   observers_.ForAllPtrs(
       [alignment](mash::shelf::mojom::ShelfObserver* observer) {
         observer->OnAlignmentChanged(alignment);
       });
 }
 
 void ShelfDelegateMus::OnShelfAutoHideBehaviorChanged(Shelf* shelf) {
   mash::shelf::mojom::AutoHideBehavior behavior =
       static_cast<mash::shelf::mojom::AutoHideBehavior>(
           shelf->auto_hide_behavior());
-  shelf_layout_->SetAutoHideBehavior(behavior);
-
   observers_.ForAllPtrs(
       [behavior](mash::shelf::mojom::ShelfObserver* observer) {
         observer->OnAutoHideBehaviorChanged(behavior);
       });
 }
 
 void ShelfDelegateMus::OnShelfAutoHideStateChanged(Shelf* shelf) {
   // Push the new preferred size to the window manager. For example, when the
   // shelf is auto-hidden it becomes a very short "light bar".
   SetShelfPreferredSizes(shelf);
@@ skipping 76 matching lines @@
   app_id_to_shelf_id_.insert(std::make_pair(app_id, shelf_id));
   shelf_id_to_app_id_.insert(std::make_pair(shelf_id, 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);
 
   std::unique_ptr<ShelfItemDelegateMus> item_delegate(
-      new ShelfItemDelegateMus(user_window_controller_.get()));
+      new ShelfItemDelegateMus());
   item_delegate->SetDelegate(std::move(delegate));
   item_delegate->set_pinned(true);
   item_delegate->set_title(item->app_title.To<base::string16>());
   model_->SetShelfItemDelegate(shelf_id, std::move(item_delegate));
 }
 
 void ShelfDelegateMus::UnpinItem(const mojo::String& app_id) {
   if (!app_id_to_shelf_id_.count(app_id.To<std::string>()))
     return;
   ShelfID shelf_id = app_id_to_shelf_id_[app_id.To<std::string>()];
@@ skipping 12 matching lines @@
   if (!app_id_to_shelf_id_.count(app_id.To<std::string>()))
     return;
   ShelfID shelf_id = app_id_to_shelf_id_[app_id.To<std::string>()];
   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 ShelfDelegateMus::OnUserWindowObserverAdded(
-    mojo::Array<ash::mojom::UserWindowPtr> user_windows) {
-  for (size_t i = 0; i < user_windows.size(); ++i)
-    OnUserWindowAdded(std::move(user_windows[i]));
-}
-
-void ShelfDelegateMus::OnUserWindowAdded(
-    ash::mojom::UserWindowPtr user_window) {
-  DCHECK(!window_id_to_shelf_id_.count(user_window->window_id));
-
-  if (user_window->ignored_by_shelf)
-    return;
-
-  std::string app_id(user_window->window_app_id.To<std::string>());
-  if (app_id_to_shelf_id_.count(app_id)) {
-    ShelfID shelf_id = app_id_to_shelf_id_[app_id];
-    window_id_to_shelf_id_.insert(
-        std::make_pair(user_window->window_id, shelf_id));
-
-    ShelfItemDelegateMus* item_delegate = GetShelfItemDelegate(shelf_id);
-    item_delegate->AddWindow(user_window->window_id,
-                             user_window->window_title.To<base::string16>());
-    return;
-  }
-
-  ShelfID shelf_id = model_->next_id();
-  window_id_to_shelf_id_.insert(
-      std::make_pair(user_window->window_id, shelf_id));
-  app_id_to_shelf_id_.insert(std::make_pair(app_id, shelf_id));
-  shelf_id_to_app_id_.insert(std::make_pair(shelf_id, app_id));
-
-  ShelfItem item;
-  item.type = TYPE_PLATFORM_APP;
-  item.status = user_window->window_has_focus ? STATUS_ACTIVE : STATUS_RUNNING;
-  item.image = GetShelfIconFromSerializedBitmap(user_window->window_app_icon);
-  model_->Add(item);
-
-  std::unique_ptr<ShelfItemDelegateMus> item_delegate(
-      new ShelfItemDelegateMus(user_window_controller_.get()));
-  item_delegate->AddWindow(user_window->window_id,
-                           user_window->window_title.To<base::string16>());
-  model_->SetShelfItemDelegate(shelf_id, std::move(item_delegate));
-}
-
-void ShelfDelegateMus::OnUserWindowRemoved(uint32_t window_id) {
-  if (!window_id_to_shelf_id_.count(window_id))
-    return;
-  ShelfID shelf_id = window_id_to_shelf_id_[window_id];
-  ShelfItemDelegateMus* item_delegate = GetShelfItemDelegate(shelf_id);
-  item_delegate->RemoveWindow(window_id);
-  window_id_to_shelf_id_.erase(window_id);
-  if (item_delegate->window_id_to_title().empty() && !item_delegate->pinned()) {
-    model_->RemoveItemAt(model_->ItemIndexByID(shelf_id));
-    const std::string& app_id = shelf_id_to_app_id_[shelf_id];
-    app_id_to_shelf_id_.erase(app_id);
-    shelf_id_to_app_id_.erase(shelf_id);
-  }
-}
-
-void ShelfDelegateMus::OnUserWindowTitleChanged(
-    uint32_t window_id,
-    const mojo::String& window_title) {
-  if (!window_id_to_shelf_id_.count(window_id))
-    return;
-  ShelfID shelf_id = window_id_to_shelf_id_[window_id];
-  ShelfItemDelegateMus* item_delegate = GetShelfItemDelegate(shelf_id);
-  item_delegate->SetWindowTitle(window_id, window_title.To<base::string16>());
-
-  // There's nothing in the ShelfItem that needs to be updated. But we still
-  // need to update the ShelfModel so that the observers can pick up any
-  // changes.
-  int index = model_->ItemIndexByID(shelf_id);
-  DCHECK_GE(index, 0);
-  ShelfItems::const_iterator iter = model_->ItemByID(shelf_id);
-  DCHECK(iter != model_->items().end());
-  model_->Set(index, *iter);
-}
-
-void ShelfDelegateMus::OnUserWindowAppIconChanged(
-    uint32_t window_id,
-    mojo::Array<uint8_t> app_icon) {
-  if (!window_id_to_shelf_id_.count(window_id))
-    return;
-  // Find the shelf ID for this window.
-  ShelfID shelf_id = window_id_to_shelf_id_[window_id];
-  DCHECK_GT(shelf_id, 0);
-
-  // Update the icon in the ShelfItem.
-  int index = model_->ItemIndexByID(shelf_id);
-  DCHECK_GE(index, 0);
-  ShelfItem item = *model_->ItemByID(shelf_id);
-  item.image = GetShelfIconFromSerializedBitmap(app_icon);
-  model_->Set(index, item);
-}
-
-void ShelfDelegateMus::OnUserWindowFocusChanged(uint32_t window_id,
-                                                bool has_focus) {
-  if (!window_id_to_shelf_id_.count(window_id))
-    return;
-  ShelfID shelf_id = window_id_to_shelf_id_[window_id];
-  int index = model_->ItemIndexByID(shelf_id);
-  DCHECK_GE(index, 0);
-  ShelfItems::const_iterator iter = model_->ItemByID(shelf_id);
-  DCHECK(iter != model_->items().end());
-  ShelfItem item = *iter;
-  item.status = has_focus ? STATUS_ACTIVE : STATUS_RUNNING;
-  model_->Set(index, item);
-}
-
 void ShelfDelegateMus::SetShelfPreferredSizes(Shelf* shelf) {
   ShelfWidget* widget = shelf->shelf_widget();
   ShelfLayoutManager* layout_manager = widget->shelf_layout_manager();
   ui::Window* window = aura::GetMusWindow(widget->GetNativeWindow());
   gfx::Size size = layout_manager->GetPreferredSize();
   window->SetSharedProperty<gfx::Size>(
       ui::mojom::WindowManager::kPreferredSize_Property, size);
 
   StatusAreaWidget* status_widget = widget->status_area_widget();
   ui::Window* status_window =
       aura::GetMusWindow(status_widget->GetNativeWindow());
   gfx::Size status_size = status_widget->GetWindowBoundsInScreen().size();
   status_window->SetSharedProperty<gfx::Size>(
       ui::mojom::WindowManager::kPreferredSize_Property, status_size);
 }
 
 }  // namespace sysui
 }  // namespace ash