arc: Add support of default and OEM apps.

chrome/browser/ui/ash/launcher/arc_app_deferred_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_deferred_launcher_controller.h"
 
 #include "chrome/browser/chromeos/arc/arc_support_host.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_deferred_launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/arc_app_window_launcher_controller.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_controller_impl.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/canvas_image_source.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/paint_throbber.h"
 
 namespace {
+
 constexpr int kUpdateIconIntervalMs = 40;  // 40ms for 25 frames per second.
 constexpr int kSpinningGapPercent = 25;
 
 class SpinningEffectSource : public gfx::CanvasImageSource {
  public:
   SpinningEffectSource(
       const base::WeakPtr<ArcAppDeferredLauncherController>& host,
       const std::string& shelf_app_id,
       const gfx::ImageSkia& image)
       : gfx::CanvasImageSource(image.size(), false /* is opaque */),
@@ skipping 26 matching lines @@
 };
 }  // namespace
 
 ArcAppDeferredLauncherController::ArcAppDeferredLauncherController(
     ChromeLauncherControllerImpl* owner)
     : owner_(owner), weak_ptr_factory_(this) {
   if (arc::ArcAuthService::IsAllowedForProfile(owner->GetProfile())) {
     observed_profile_ = owner->GetProfile();
     ArcAppListPrefs::Get(observed_profile_)->AddObserver(this);
   }
+  arc::ArcAuthService* auth_service = arc::ArcAuthService::Get();
+  if (auth_service)
+    auth_service->AddObserver(this);

[Mr4D (OOO till 08-26), 2016/08/30 20:21:46]

Just checking - is it guaranteed that the lifetime of the object is entirely
including the lifetime of these controllers? (so does it get created before the
first object is created and does it get destroyed after the last one goes away?

Furthermore - when can this be null? Would a DCHECK work, or is this for unit
tests? If the latter - please add a comment about that.

[khmel, 2016/08/30 21:22:11]

Actually we have unit tests were ArcAuthService might be NULL.
ArcAppDeferredLauncherController is always created in ChromeLauncherController
so we should support tests here. Comments added. Currently ArcBridgeService and
ArcAuthService get released before Shelf deleting. So currently this DTOR is
called after ArcAuthService DTOR (which sets its instance to nullptr).

 }
 
 ArcAppDeferredLauncherController::~ArcAppDeferredLauncherController() {
+  arc::ArcAuthService* auth_service = arc::ArcAuthService::Get();
+  if (auth_service)
+    auth_service->RemoveObserver(this);
   if (observed_profile_)
     ArcAppListPrefs::Get(observed_profile_)->RemoveObserver(this);
 }
 
 void ArcAppDeferredLauncherController::MaybeApplySpinningEffect(
     const std::string& shelf_app_id,
     gfx::ImageSkia* image) {
   DCHECK(image);
   if (app_controller_map_.find(shelf_app_id) == app_controller_map_.end())
     return;
@@ skipping 44 matching lines @@
 
   Close(app_id);
 
   arc::LaunchApp(owner_->GetProfile(), app_id);
 }
 
 void ArcAppDeferredLauncherController::OnAppRemoved(const std::string& app_id) {
   Close(app_id);
 }
 
+void ArcAppDeferredLauncherController::OnOptInEnabled(bool enabled) {
+  // If Arc was disabled, remove all deferred launch requests.

[Mr4D (OOO till 08-26), 2016/08/30 20:21:46]

I suppose you want to move this comment to line 143?

[khmel, 2016/08/30 21:22:11]

Right, that the better place

+  if (enabled)
+    return;
+
+  while (!app_controller_map_.empty())
+    Close(app_controller_map_.begin()->first);
+}
+
+bool ArcAppDeferredLauncherController::HasApp(const std::string& app_id) const {
+  const std::string shelf_app_id =
+      ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(app_id);
+  return app_controller_map_.count(shelf_app_id);
+}
+
 base::TimeDelta ArcAppDeferredLauncherController::GetActiveTime(
     const std::string& shelf_app_id) const {
   AppControllerMap::const_iterator it = app_controller_map_.find(shelf_app_id);
   if (it == app_controller_map_.end())
     return base::TimeDelta();
 
   return it->second->GetActiveTime();
 }
 
 void ArcAppDeferredLauncherController::UpdateApps() {
   if (app_controller_map_.empty())
     return;
 
   RegisterNextUpdate();
   for (const auto pair : app_controller_map_)
     owner_->OnAppUpdated(owner_->GetProfile(), pair.first);
 }
 
 void ArcAppDeferredLauncherController::RegisterNextUpdate() {
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&ArcAppDeferredLauncherController::UpdateApps,
                             weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kUpdateIconIntervalMs));
 }
 
 void ArcAppDeferredLauncherController::RegisterDeferredLaunch(
     const std::string& app_id) {
+  const arc::ArcAuthService* auth_service = arc::ArcAuthService::Get();
+  DCHECK(auth_service);
+  DCHECK(auth_service->state() != arc::ArcAuthService::State::STOPPED);
+  DCHECK(auth_service->state() != arc::ArcAuthService::State::NOT_INITIALIZED);
+
   const std::string shelf_app_id =
       ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(app_id);
   const ash::ShelfID shelf_id = owner_->GetShelfIDForAppID(shelf_app_id);
 
   if (shelf_id) {
     LauncherItemController* controller =
         owner_->GetLauncherItemController(shelf_id);
     if (controller &&
         controller->type() != LauncherItemController::TYPE_SHORTCUT) {
       // We are allowed to apply new deferred controller only over shortcut.
@@ skipping 10 matching lines @@
   } else {
     owner_->SetItemController(shelf_id, controller);
     owner_->SetItemStatus(shelf_id, ash::STATUS_RUNNING);
   }
 
   if (app_controller_map_.empty())
     RegisterNextUpdate();
 
   app_controller_map_[shelf_app_id] = controller;
 }