src/athena/content/app_activity_registry.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "athena/content/app_activity_registry.h"
   6
   7 #include "athena/activity/public/activity_manager.h"
   8 #include "athena/content/app_activity.h"
   9 #include "athena/content/app_activity_proxy.h"
  10 #include "athena/content/public/app_registry.h"
  11 #include "athena/extensions/public/extensions_delegate.h"
  12 #include "athena/resource_manager/public/resource_manager.h"
  13 #include "athena/wm/public/window_list_provider.h"
  14 #include "athena/wm/public/window_manager.h"
  15 #include "base/bind.h"
  16 #include "base/location.h"
  17 #include "base/single_thread_task_runner.h"
  18 #include "base/thread_task_runner_handle.h"
  19 #include "ui/aura/window.h"
  20 #include "ui/views/view.h"
  21 #include "ui/views/widget/widget.h"
  22
  23 namespace athena {
  24
  25 AppActivityRegistry::AppActivityRegistry(
  26     const std::string& app_id,
  27     content::BrowserContext* browser_context)
  28     : app_id_(app_id),
  29       browser_context_(browser_context),
  30       unloaded_activity_proxy_(nullptr) {
  31 }
  32
  33 AppActivityRegistry::~AppActivityRegistry() {
  34   CHECK(activity_list_.empty());
  35   if (unloaded_activity_proxy_)
  36     ActivityManager::Get()->RemoveActivity(unloaded_activity_proxy_);
  37   DCHECK(!unloaded_activity_proxy_);
  38 }
  39
  40 void AppActivityRegistry::RegisterAppActivity(AppActivity* app_activity) {
  41   // The same window should never be added twice.
  42   CHECK(std::find(activity_list_.begin(),
  43                   activity_list_.end(),
  44                   app_activity) == activity_list_.end());
  45   activity_list_.push_back(app_activity);
  46 }
  47
  48 void AppActivityRegistry::UnregisterAppActivity(AppActivity* app_activity) {
  49   // It is possible that a detach gets called without ever being attached.
  50   std::vector<AppActivity*>::iterator it =
  51       std::find(activity_list_.begin(), activity_list_.end(), app_activity);
  52   if (it == activity_list_.end())
  53     return;
  54
  55   activity_list_.erase(it);
  56   // When the last window gets destroyed and there is no proxy to restart, we
  57   // delete ourselves.
  58   if (activity_list_.empty() && !unloaded_activity_proxy_) {
  59     AppRegistry::Get()->RemoveAppActivityRegistry(this);
  60     // after this call this object should be gone.
  61   }
  62 }
  63
  64 AppActivity* AppActivityRegistry::GetAppActivityAt(size_t index) {
  65   if (index >= activity_list_.size())
  66     return nullptr;
  67   return activity_list_[index];
  68 }
  69
  70 void AppActivityRegistry::Unload() {
  71   CHECK(!unloaded_activity_proxy_);
  72   DCHECK(!activity_list_.empty());
  73   // In order to allow an entire application to unload we require that all of
  74   // its activities are marked as unloaded.
  75   for (std::vector<AppActivity*>::iterator it = activity_list_.begin();
  76        it != activity_list_.end(); ++it) {
  77     if ((*it)->GetCurrentState() != Activity::ACTIVITY_UNLOADED)
  78       return;
  79   }
  80
  81   // Create an activity proxy which can be used to re-activate the app. Insert
  82   // the proxy then into the activity stream at the location of the (newest)
  83   // current activity.
  84   unloaded_activity_proxy_ = new AppActivityProxy(GetMruActivity(), this);
  85   ActivityManager::Get()->AddActivity(unloaded_activity_proxy_);
  86   unloaded_activity_proxy_->GetWindow()->SetName("AppActivityProxy");
  87
  88   // This function can be called through an observer call. When that happens,
  89   // several activities will be closed / started. That can then cause a crash.
  90   // We postpone therefore the activity destruction till after the observer is
  91   // done.
  92   base::ThreadTaskRunnerHandle::Get()->PostTask(
  93       FROM_HERE,
  94       base::Bind(&AppActivityRegistry::DelayedUnload, base::Unretained(this)));
  95 }
  96
  97 void AppActivityRegistry::ProxyDestroyed(AppActivityProxy* proxy) {
  98   DCHECK_EQ(unloaded_activity_proxy_, proxy);
  99   unloaded_activity_proxy_ = nullptr;
 100   if (activity_list_.empty()) {
 101     AppRegistry::Get()->RemoveAppActivityRegistry(this);
 102     // |This| is gone now.
 103   }
 104 }
 105
 106 void AppActivityRegistry::RestartApplication(AppActivityProxy* proxy) {
 107   DCHECK_EQ(unloaded_activity_proxy_, proxy);
 108   // Restart the application. Note that the first created app window will make
 109   // sure that the proxy gets deleted - after - the new activity got moved
 110   // to the proxies activity location.
 111   ExtensionsDelegate::Get(browser_context_)->LaunchApp(app_id_);
 112 }
 113
 114 void AppActivityRegistry::DelayedUnload() {
 115   if (!ExtensionsDelegate::Get(browser_context_)->UnloadApp(app_id_)) {
 116     while(!activity_list_.empty())
 117       Activity::Delete(activity_list_.back());
 118   }
 119 }
 120
 121 AppActivity* AppActivityRegistry::GetMruActivity() {
 122   DCHECK(activity_list_.size());
 123   WindowListProvider* window_list_provider =
 124       WindowManager::Get()->GetWindowListProvider();
 125   const aura::Window::Windows& children =
 126       window_list_provider->GetWindowList();
 127   // Find the first window in the container which is part of the application.
 128   for (aura::Window::Windows::const_iterator child_iterator = children.begin();
 129       child_iterator != children.end(); ++child_iterator) {
 130     for (std::vector<AppActivity*>::iterator app_iterator =
 131              activity_list_.begin();
 132          app_iterator != activity_list_.end(); ++app_iterator) {
 133       if (*child_iterator == (*app_iterator)->GetWindow())
 134         return *app_iterator;
 135     }
 136   }
 137   NOTREACHED() << "The application does not get tracked by the mru list";
 138   return nullptr;
 139 }
 140
 141 }  // namespace athena