arc: Set custom icon in shelf for ARC apps.

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_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_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
+#include "chrome/browser/ui/ash/launcher/arc_app_window.h"
 #include "chrome/browser/ui/ash/launcher/arc_app_window_launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_window_manager.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/exo/shell_surface.h"
 #include "components/signin/core/account_id/account_id.h"
 #include "components/user_manager/user_manager.h"
 #include "third_party/WebKit/public/platform/modules/screen_orientation/WebScreenOrientationLockType.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/base/base_window.h"
 #include "ui/display/display.h"
 #include "ui/display/manager/display_manager.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 
-enum class FullScreenMode {
-  NOT_DEFINED,  // Fullscreen mode was not defined.
-  ACTIVE,       // Fullscreen is activated for an app.
-  NON_ACTIVE,   // Fullscreen was not activated for an app.
-};
-
 blink::WebScreenOrientationLockType BlinkOrientationLockFromMojom(
     arc::mojom::OrientationLock orientation_lock) {
   DCHECK_NE(arc::mojom::OrientationLock::CURRENT, orientation_lock);
   switch (orientation_lock) {
     case arc::mojom::OrientationLock::PORTRAIT:
       return blink::kWebScreenOrientationLockPortrait;
     case arc::mojom::OrientationLock::LANDSCAPE:
       return blink::kWebScreenOrientationLockLandscape;
     case arc::mojom::OrientationLock::PORTRAIT_PRIMARY:
       return blink::kWebScreenOrientationLockPortraitPrimary;
@@ skipping 13 matching lines @@
 using ash::ScreenOrientationController;
 
 // The information about the arc application window which has to be kept
 // even when its AppWindow is not present.
 class ArcAppWindowLauncherController::AppWindowInfo {
  public:
   explicit AppWindowInfo(const arc::ArcAppShelfId& app_shelf_id)
       : app_shelf_id_(app_shelf_id) {}
   ~AppWindowInfo() = default;
 
+  void SetDescription(const std::string& title,
+                      const std::vector<uint8_t>& icon_data_png) {
+    title_ = title;

[nasko, 2017/05/23 05:02:31]

This data comes from untrusted process, so some verification should be
performed. Is there any limit that applies to titles? Is it expected to be UTF-8
or some other encoding?

[khmel, 2017/05/23 15:33:28]

Yes, it is expected that this is UTF_8. IIUC UTF8ToUTF16 is safe.

[nasko, 2017/05/23 21:52:29]

It is not just a matter whether the conversion functions are safe or not, the
data comes from untrusted source, so we need to ensure we validate it. Why not
pass it through base::IsStringUTF8?

[khmel, 2017/05/24 00:09:52]

I tried to find similar but could not (well, name itself is simple :)). Thank
you for reference! Done. 

+    // Chrome has custom Play Store icon. Don't overwrite it.
+    if (app_shelf_id_.app_id() != arc::kPlayStoreAppId)
+      icon_data_png_ = icon_data_png;

[nasko, 2017/05/23 05:02:31]

I don't know if there is much to be verified here, but if there are any known
constraints on the data, it will be good to check them here.

[khmel, 2017/05/23 15:33:28]

I can suggest to limit this by size. Normally this is around 6-12kb. I think 64
kb limit could be good for this. Besides, png data is decoded in sandboxed
process so it should be safe.

[reveman, 2017/05/23 16:46:17]

Oh, didn't know we used a sandboxed process for this. What process is that? Do
we have a dedicated image decode process in chrome that I wasn't aware of?

[khmel, 2017/05/23 16:52:49]

I know only high level details:
https://cs.chromium.org/chromium/src/chrome/browser/image_decoder.h?type=cs&l=24
This is way we work with ARC icons. We already used this approach for decoding
default app icon, shortcuts icon (probably more).

[nasko, 2017/05/23 21:52:29]

While decoding in sandboxed process is awesome for security, we still need to
validate data coming from that process. If the data is specially crafted to
exploit a bug and get arbitrary code execution, then the sandboxed process can
easily send us completely bogus data or one specially crafted to exploit other
memory bugs in the more privileged process.

Thanks for adding the size check!

[khmel, 2017/05/24 00:09:51]

Acknowledged. Thanks for sharing your knowledge!

+  }
+
+  void set_app_window(std::unique_ptr<ArcAppWindow> window) {
+    app_window_ = std::move(window);
+  }
+
   const arc::ArcAppShelfId& app_shelf_id() const { return app_shelf_id_; }
 
   bool has_requested_orientation_lock() const {
     return has_requested_orientation_lock_;
   }
 
   void set_requested_orientation_lock(arc::mojom::OrientationLock lock) {
     has_requested_orientation_lock_ = true;
     requested_orientation_lock_ = lock;
   }
 
   arc::mojom::OrientationLock requested_orientation_lock() const {
     return requested_orientation_lock_;
   }
 
   void set_lock_completion_behavior(
       ScreenOrientationController::LockCompletionBehavior lock_behavior) {
     lock_completion_behavior_ = lock_behavior;
   }
 
   ScreenOrientationController::LockCompletionBehavior lock_completion_behavior()
       const {
     return lock_completion_behavior_;
   }
 
-  void set_app_window(std::unique_ptr<AppWindow> window) {
-    app_window_ = std::move(window);
-  }
+  ArcAppWindow* app_window() { return app_window_.get(); }
 
-  AppWindow* app_window() { return app_window_.get(); }
+  const std::string& title() const { return title_; }
+
+  const std::vector<uint8_t>& icon_data_png() const { return icon_data_png_; }
 
  private:
   const arc::ArcAppShelfId app_shelf_id_;
   bool has_requested_orientation_lock_ = false;
 
   // If true, the orientation should be locked to the specific
   // orientation after the requested_orientation_lock is applied.
   // This is meaningful only if the orientation is one of ::NONE,
   // ::PORTRAIT or ::LANDSCAPE.
   ScreenOrientationController::LockCompletionBehavior
       lock_completion_behavior_ =
           ScreenOrientationController::LockCompletionBehavior::None;
   arc::mojom::OrientationLock requested_orientation_lock_ =
       arc::mojom::OrientationLock::NONE;
-  std::unique_ptr<AppWindow> app_window_;
+  // Keeps overridden window title.
+  std::string title_;
+  // Keeps overridden window icon.
+  std::vector<uint8_t> icon_data_png_;
+  std::unique_ptr<ArcAppWindow> app_window_;
 
   DISALLOW_COPY_AND_ASSIGN(AppWindowInfo);
 };
 
-// A ui::BaseWindow for a chromeos launcher to control ARC applications.
-class ArcAppWindowLauncherController::AppWindow : public ui::BaseWindow {
- public:
-  AppWindow(int task_id,
-            const arc::ArcAppShelfId& app_shelf_id,
-            views::Widget* widget,
-            ArcAppWindowLauncherController* owner)
-      : task_id_(task_id),
-        app_shelf_id_(app_shelf_id),
-        widget_(widget),
-        owner_(owner) {}
-  ~AppWindow() = default;
-
-  void SetController(ArcAppWindowLauncherItemController* controller) {
-    DCHECK(!controller_ && controller);
-    controller_ = controller;
-  }
-
-  void ResetController() { controller_ = nullptr; }
-
-  void SetFullscreenMode(FullScreenMode mode) {
-    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_; }
-
-  const ash::ShelfID& shelf_id() const { return 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_;
-  }
-
-  bool IsMaximized() const override {
-    NOTREACHED();
-    return false;
-  }
-
-  bool IsMinimized() const override {
-    NOTREACHED();
-    return false;
-  }
-
-  bool IsFullscreen() const override {
-    NOTREACHED();
-    return false;
-  }
-
-  gfx::NativeWindow GetNativeWindow() const override {
-    return widget_->GetNativeWindow();
-  }
-
-  gfx::Rect GetRestoredBounds() const override {
-    NOTREACHED();
-    return gfx::Rect();
-  }
-
-  ui::WindowShowState GetRestoredState() const override {
-    NOTREACHED();
-    return ui::SHOW_STATE_NORMAL;
-  }
-
-  gfx::Rect GetBounds() const override {
-    NOTREACHED();
-    return gfx::Rect();
-  }
-
-  void Show() override { widget_->Show(); }
-
-  void ShowInactive() override { NOTREACHED(); }
-
-  void Hide() override { NOTREACHED(); }
-
-  void Close() override { arc::CloseTask(task_id_); }
-
-  void Activate() override { widget_->Activate(); }
-
-  void Deactivate() override { NOTREACHED(); }
-
-  void Maximize() override { NOTREACHED(); }
-
-  void Minimize() override { widget_->Minimize(); }
-
-  void Restore() override { NOTREACHED(); }
-
-  void SetBounds(const gfx::Rect& bounds) override { NOTREACHED(); }
-
-  void FlashFrame(bool flash) override { NOTREACHED(); }
-
-  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_;
-  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);
-};
-
 ArcAppWindowLauncherController::ArcAppWindowLauncherController(
     ChromeLauncherController* owner)
     : AppWindowLauncherController(owner) {
   if (arc::IsArcAllowedForProfile(owner->profile())) {
     observed_profile_ = owner->profile();
     StartObserving(observed_profile_);
   }
 }
 
 ArcAppWindowLauncherController::~ArcAppWindowLauncherController() {
@@ skipping 91 matching lines @@
     UnregisterApp(info_it->second.get());
   }
 }
 
 ArcAppWindowLauncherController::AppWindowInfo*
 ArcAppWindowLauncherController::GetAppWindowInfoForTask(int task_id) {
   const auto it = task_id_to_app_window_info_.find(task_id);
   return it == task_id_to_app_window_info_.end() ? nullptr : it->second.get();
 }
 
-ArcAppWindowLauncherController::AppWindow*
-ArcAppWindowLauncherController::GetAppWindowForTask(int task_id) {
+ArcAppWindow* ArcAppWindowLauncherController::GetAppWindowForTask(int task_id) {
   AppWindowInfo* info = GetAppWindowInfoForTask(task_id);
   return info ? info->app_window() : nullptr;
 }
 
 void ArcAppWindowLauncherController::AttachControllerToWindowsIfNeeded() {
   for (auto* window : observed_windows_)
     AttachControllerToWindowIfNeeded(window);
 }
 
 void ArcAppWindowLauncherController::AttachControllerToWindowIfNeeded(
@@ skipping 20 matching lines @@
   // Create controller if we have task info.
   AppWindowInfo* info = GetAppWindowInfoForTask(task_id);
   if (!info) {
     VLOG(1) << "Could not find AppWindowInfo for task:" << task_id;
     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));
+  info->set_app_window(base::MakeUnique<ArcAppWindow>(
+      task_id, info->app_shelf_id(), widget, this));
+  info->app_window()->SetDescription(info->title(), info->icon_data_png());
   RegisterApp(info);
   DCHECK(info->app_window()->controller());
   const ash::ShelfID shelf_id(info->app_window()->shelf_id());
   window->SetProperty(ash::kShelfIDKey, new std::string(shelf_id.Serialize()));
   if (ash::Shell::Get()
           ->maximize_mode_controller()
           ->IsMaximizeModeWindowManagerEnabled()) {
     SetOrientationLockForAppWindow(info->app_window());
   }
 }
 
 void ArcAppWindowLauncherController::OnAppReadyChanged(
     const std::string& arc_app_id,
     bool ready) {
   if (!ready)
     OnAppRemoved(arc_app_id);
 }
 
 std::vector<int> ArcAppWindowLauncherController::GetTaskIdsForApp(
     const std::string& arc_app_id) const {
-  // Note, AppWindow is optional part for a task and it may be not created if
+  // Note, ArcAppWindow is optional part for a task and it may be not created if
   // another full screen Android app is currently active. Use
   // |task_id_to_app_window_info_| that keeps currently running tasks info.
   std::vector<int> task_ids;
   for (const auto& it : task_id_to_app_window_info_) {
     const AppWindowInfo* app_window_info = it.second.get();
     if (app_window_info->app_shelf_id().app_id() == arc_app_id)
       task_ids.push_back(it.first);
   }
 
   return task_ids;
@@ skipping 24 matching lines @@
     return;
 
   AttachControllerToWindowsIfNeeded();
 
   // Some tasks can be started in background and might have no window until
   // pushed to the front. We need its representation on the shelf to give a user
   // control over it.
   AttachControllerToTask(task_id, *task_id_to_app_window_info_[task_id]);
 }
 
+void ArcAppWindowLauncherController::OnTaskDescriptionUpdated(
+    int32_t task_id,
+    const std::string& label,
+    const std::vector<uint8_t>& icon_png_data) {
+  AppWindowInfo* info = GetAppWindowInfoForTask(task_id);
+  if (info) {
+    info->SetDescription(label, icon_png_data);
+    if (info->app_window())
+      info->app_window()->SetDescription(label, icon_png_data);
+  }
+}
+
 void ArcAppWindowLauncherController::OnTaskDestroyed(int task_id) {
   auto it = task_id_to_app_window_info_.find(task_id);
   if (it == task_id_to_app_window_info_.end())
     return;
 
   UnregisterApp(it->second.get());
 
   // Check if we may close controller now, at this point we can safely remove
   // controllers without window.
   auto it_controller =
       app_shelf_group_to_controller_map_.find(it->second->app_shelf_id());
   if (it_controller != app_shelf_group_to_controller_map_.end()) {
     it_controller->second->RemoveTaskId(task_id);
     if (!it_controller->second->HasAnyTasks()) {
       owner()->CloseLauncherItem(it_controller->second->shelf_id());
       app_shelf_group_to_controller_map_.erase(it_controller);
     }
   }
 
   task_id_to_app_window_info_.erase(it);
 }
 
-void ArcAppWindowLauncherController::OnTaskSetActive(int32_t task_id) {
-  if (observed_profile_ != owner()->profile()) {
-    active_task_id_ = task_id;
-    return;
-  }
-
-  AppWindow* previous_app_window = GetAppWindowForTask(active_task_id_);
-  if (previous_app_window) {
-    owner()->SetItemStatus(previous_app_window->shelf_id(),
-                           ash::STATUS_RUNNING);
-    previous_app_window->SetFullscreenMode(
-        previous_app_window->widget() &&
-                previous_app_window->widget()->IsFullscreen()
-            ? FullScreenMode::ACTIVE
-            : FullScreenMode::NON_ACTIVE);
-  }
-
-  active_task_id_ = task_id;
-
-  AppWindow* current_app_window = GetAppWindowForTask(task_id);
-  if (current_app_window) {
-    owner()->SetItemStatus(
-        current_app_window->shelf_id(),
-        current_app_window->widget() && current_app_window->IsActive()
-            ? ash::STATUS_ACTIVE
-            : ash::STATUS_RUNNING);
-    // TODO(reveman): Figure out how to support fullscreen in interleaved
-    // window mode.
-    // if (new_active_app_it->second->widget()) {
-    //   new_active_app_it->second->widget()->SetFullscreen(
-    //       new_active_app_it->second->fullscreen_mode() ==
-    //       FullScreenMode::ACTIVE);
-    // }
-  }
-}
-
 void ArcAppWindowLauncherController::OnTaskOrientationLockRequested(
     int32_t task_id,
     const arc::mojom::OrientationLock orientation_lock) {
   // Don't save to AppInfo in prefs because this is requested in runtime.
   AppWindowInfo* info = GetAppWindowInfoForTask(task_id);
   DCHECK(info);
   if (!info)
     return;
 
   if (orientation_lock == arc::mojom::OrientationLock::CURRENT) {
     info->set_lock_completion_behavior(
         ScreenOrientationController::LockCompletionBehavior::DisableSensor);
     if (!info->has_requested_orientation_lock()) {
       info->set_requested_orientation_lock(arc::mojom::OrientationLock::NONE);
     }
   } else {
     info->set_requested_orientation_lock(orientation_lock);
     info->set_lock_completion_behavior(
         ScreenOrientationController::LockCompletionBehavior::None);
   }
 
   if (ash::Shell::Get()
           ->maximize_mode_controller()
           ->IsMaximizeModeWindowManagerEnabled()) {
-    AppWindow* app_window = info->app_window();
+    ArcAppWindow* app_window = info->app_window();
     if (app_window)
       SetOrientationLockForAppWindow(app_window);
   }
 }
 
+void ArcAppWindowLauncherController::OnTaskSetActive(int32_t task_id) {
+  if (observed_profile_ != owner()->profile()) {
+    active_task_id_ = task_id;
+    return;
+  }
+
+  ArcAppWindow* previous_app_window = GetAppWindowForTask(active_task_id_);
+  if (previous_app_window) {
+    owner()->SetItemStatus(previous_app_window->shelf_id(),
+                           ash::STATUS_RUNNING);
+    previous_app_window->SetFullscreenMode(
+        previous_app_window->widget() &&
+                previous_app_window->widget()->IsFullscreen()
+            ? ArcAppWindow::FullScreenMode::ACTIVE
+            : ArcAppWindow::FullScreenMode::NON_ACTIVE);
+  }
+
+  active_task_id_ = task_id;
+
+  ArcAppWindow* current_app_window = GetAppWindowForTask(task_id);
+  if (current_app_window) {
+    if (current_app_window->widget() && current_app_window->IsActive()) {
+      owner()->SetItemStatus(current_app_window->shelf_id(),
+                             ash::STATUS_ACTIVE);
+      current_app_window->controller()->SetActiveWindow(
+          current_app_window->GetNativeWindow());
+    } else {
+      owner()->SetItemStatus(current_app_window->shelf_id(),
+                             ash::STATUS_RUNNING);
+    }
+    // TODO(reveman): Figure out how to support fullscreen in interleaved
+    // window mode.
+    // if (new_active_app_it->second->widget()) {
+    //   new_active_app_it->second->widget()->SetFullscreen(
+    //       new_active_app_it->second->fullscreen_mode() ==
+    //       ArcAppWindow::FullScreenMode::ACTIVE);
+    // }
+  }
+}
+
 AppWindowLauncherItemController*
 ArcAppWindowLauncherController::ControllerForWindow(aura::Window* window) {
   if (!window)
     return nullptr;
 
-  AppWindow* app_window = GetAppWindowForTask(active_task_id_);
+  ArcAppWindow* app_window = GetAppWindowForTask(active_task_id_);
   if (app_window &&
       app_window->widget() == views::Widget::GetWidgetForNativeWindow(window)) {
     return app_window->controller();
   }
 
   for (auto& it : task_id_to_app_window_info_) {
-    AppWindow* app_window = it.second->app_window();
+    ArcAppWindow* app_window = it.second->app_window();
     if (app_window &&
         app_window->widget() ==
             views::Widget::GetWidgetForNativeWindow(window)) {
       return it.second->app_window()->controller();
     }
   }
 
   return nullptr;
 }
 
 void ArcAppWindowLauncherController::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   AppWindowLauncherController::OnWindowActivated(reason, gained_active,
                                                  lost_active);
   OnTaskSetActive(active_task_id_);
 }
 
 void ArcAppWindowLauncherController::OnMaximizeModeStarted() {
   for (auto& it : task_id_to_app_window_info_) {
-    AppWindow* app_window = it.second->app_window();
+    ArcAppWindow* app_window = it.second->app_window();
     if (app_window)
       SetOrientationLockForAppWindow(app_window);
   }
 }
 
 void ArcAppWindowLauncherController::OnMaximizeModeEnded() {
   ash::ScreenOrientationController* orientation_controller =
       ash::Shell::Get()->screen_orientation_controller();
   // Don't unlock one by one because it'll switch to next rotation.
   orientation_controller->UnlockAll();
@@ skipping 25 matching lines @@
   const arc::ArcAppShelfId& app_shelf_id = app_window_info.app_shelf_id();
   const auto it = app_shelf_group_to_controller_map_.find(app_shelf_id);
   if (it != app_shelf_group_to_controller_map_.end()) {
     DCHECK_EQ(it->second->app_id(), app_shelf_id.ToString());
     it->second->AddTaskId(task_id);
     return it->second;
   }
 
   std::unique_ptr<ArcAppWindowLauncherItemController> controller =
       base::MakeUnique<ArcAppWindowLauncherItemController>(
-          app_shelf_id.ToString());
+          app_shelf_id.ToString(), owner());
   ArcAppWindowLauncherItemController* item_controller = controller.get();
   const ash::ShelfID shelf_id(app_shelf_id.ToString());
   if (!owner()->GetItem(shelf_id)) {
     owner()->CreateAppLauncherItem(std::move(controller), ash::STATUS_RUNNING);
   } else {
     owner()->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();
+  ArcAppWindow* app_window = app_window_info->app_window();
   ArcAppWindowLauncherItemController* controller =
       AttachControllerToTask(app_window->task_id(), *app_window_info);
   DCHECK(!controller->app_id().empty());
   const ash::ShelfID shelf_id(controller->app_id());
   DCHECK(owner()->GetItem(shelf_id));
 
   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();
+  ArcAppWindow* app_window = app_window_info->app_window();
   if (!app_window)
     return;
 
   ArcAppWindowLauncherItemController* controller = app_window->controller();
   if (controller)
     controller->RemoveWindow(app_window);
-  app_window->ResetController();
+  app_window->SetController(nullptr);
   app_window_info->set_app_window(nullptr);
 }
 
 void ArcAppWindowLauncherController::SetOrientationLockForAppWindow(
-    AppWindow* app_window) {
+    ArcAppWindow* app_window) {
   ash::WmWindow* window =
       ash::WmWindow::Get(app_window->widget()->GetNativeWindow());
   if (!window)
     return;
   AppWindowInfo* info = GetAppWindowInfoForTask(app_window->task_id());
   arc::mojom::OrientationLock orientation_lock;
 
   ScreenOrientationController::LockCompletionBehavior lock_completion_behavior =
       ScreenOrientationController::LockCompletionBehavior::None;
   if (info->has_requested_orientation_lock()) {
@@ skipping 23 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;
 }