mash: Replace int ShelfIDs with AppLaunchID strings.

chrome/browser/ui/ash/launcher/arc_app_window_launcher_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 "chrome/browser/ui/ash/launcher/arc_app_window_launcher_controller.h"
 
 #include <string>
 
 #include "ash/display/screen_orientation_controller_chromeos.h"
+#include "ash/public/cpp/window_properties.h"
 #include "ash/shared/app_types.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shell.h"
 #include "ash/wm/maximize_mode/maximize_mode_controller.h"
-#include "ash/wm/window_properties.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm_window.h"
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/chromeos/arc/arc_support_host.h"
 #include "chrome/browser/chromeos/arc/arc_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
@@ skipping 126 matching lines @@
     DCHECK(mode != FullScreenMode::NOT_DEFINED);
     fullscreen_mode_ = mode;
   }
 
   FullScreenMode fullscreen_mode() const { return fullscreen_mode_; }
 
   int task_id() const { return task_id_; }
 
   const arc::ArcAppShelfId& app_shelf_id() const { return app_shelf_id_; }
 
-  ash::ShelfID shelf_id() const { return shelf_id_; }
+  const ash::ShelfID& shelf_id() const { return shelf_id_; }
 
-  void set_shelf_id(ash::ShelfID shelf_id) { shelf_id_ = shelf_id; }
+  void set_shelf_id(const ash::ShelfID& shelf_id) { shelf_id_ = shelf_id; }
 
   views::Widget* widget() const { return widget_; }
 
   ArcAppWindowLauncherItemController* controller() { return controller_; }
 
   // ui::BaseWindow:
   bool IsActive() const override {
     return widget_->IsActive() && owner_->active_task_id_ == task_id_;
   }
 
@@ skipping 56 matching lines @@
   bool IsAlwaysOnTop() const override {
     NOTREACHED();
     return false;
   }
 
   void SetAlwaysOnTop(bool always_on_top) override { NOTREACHED(); }
 
  private:
   const int task_id_;
   const arc::ArcAppShelfId app_shelf_id_;
-  ash::ShelfID shelf_id_ = 0;
+  ash::ShelfID shelf_id_;
   FullScreenMode fullscreen_mode_ = FullScreenMode::NOT_DEFINED;
   // Unowned pointers
   views::Widget* const widget_;
   ArcAppWindowLauncherController* owner_;
   ArcAppWindowLauncherItemController* controller_ = nullptr;
   // Unowned pointer, represents host ARC window.
 
   DISALLOW_COPY_AND_ASSIGN(AppWindow);
 };
 
@@ skipping 161 matching lines @@
     return;
   }
 
   views::Widget* widget = views::Widget::GetWidgetForNativeWindow(window);
   DCHECK(widget);
   DCHECK(!info->app_window());
   info->set_app_window(
       base::MakeUnique<AppWindow>(task_id, info->app_shelf_id(), widget, this));
   RegisterApp(info);
   DCHECK(info->app_window()->controller());
-  window->SetProperty(ash::kShelfIDKey, info->app_window()->shelf_id());
+  window->SetProperty(ash::kShelfIDKey,
+                      new ash::ShelfID(info->app_window()->shelf_id()));
   if (ash::Shell::Get()
           ->maximize_mode_controller()
           ->IsMaximizeModeWindowManagerEnabled()) {
     SetOrientationLockForAppWindow(info->app_window());
   }
 }
 
 void ArcAppWindowLauncherController::OnAppReadyChanged(
     const std::string& arc_app_id,
     bool ready) {
@@ skipping 217 matching lines @@
     return it->second;
   }
 
   std::unique_ptr<ArcAppWindowLauncherItemController> controller =
       base::MakeUnique<ArcAppWindowLauncherItemController>(
           app_shelf_id.ToString());
   ArcAppWindowLauncherItemController* item_controller = controller.get();
   ash::ShelfModel* shelf_model = ash::Shell::Get()->shelf_model();
   const ash::ShelfID shelf_id =
       shelf_model->GetShelfIDForAppID(app_shelf_id.ToString());
-  if (shelf_id == ash::kInvalidShelfID) {
+  if (shelf_id.IsEmpty()) {
     owner()->CreateAppLauncherItem(std::move(controller), ash::STATUS_RUNNING);
   } else {
     shelf_model->SetShelfItemDelegate(shelf_id, std::move(controller));
     owner()->SetItemStatus(shelf_id, ash::STATUS_RUNNING);
   }
   item_controller->AddTaskId(task_id);
   app_shelf_group_to_controller_map_[app_shelf_id] = item_controller;
   return item_controller;
 }
 
 void ArcAppWindowLauncherController::RegisterApp(
     AppWindowInfo* app_window_info) {
   AppWindow* app_window = app_window_info->app_window();
   ArcAppWindowLauncherItemController* controller =
       AttachControllerToTask(app_window->task_id(), *app_window_info);
   DCHECK(controller);
 
   const ash::ShelfID shelf_id =
       ash::Shell::Get()->shelf_model()->GetShelfIDForAppID(
           controller->app_id());
-  DCHECK_NE(shelf_id, ash::kInvalidShelfID);
+  DCHECK(!shelf_id.IsEmpty());
 
   controller->AddWindow(app_window);
   owner()->SetItemStatus(shelf_id, ash::STATUS_RUNNING);
   app_window->SetController(controller);
   app_window->set_shelf_id(shelf_id);
 }
 
 void ArcAppWindowLauncherController::UnregisterApp(
     AppWindowInfo* app_window_info) {
   AppWindow* app_window = app_window_info->app_window();
@@ skipping 45 matching lines @@
   const std::string arc_app_id = exo::ShellSurface::GetApplicationId(window);
   if (arc_app_id.empty())
     return -1;
 
   int task_id = -1;
   if (sscanf(arc_app_id.c_str(), "org.chromium.arc.%d", &task_id) != 1)
     return -1;
 
   return task_id;
 }