Decoupling visibility states from webcontent, adding visibility management in ResourceManager

athena/content/app_activity_registry.cc

 // Copyright 2014 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 "athena/content/app_activity_registry.h"
 
 #include "athena/activity/public/activity_manager.h"
 #include "athena/content/app_activity.h"
 #include "athena/content/app_activity_proxy.h"
 #include "athena/content/public/app_registry.h"
 #include "athena/extensions/public/extensions_delegate.h"
+#include "athena/resource_manager/public/resource_manager.h"
 #include "ui/aura/window.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 namespace athena {
 
 AppActivityRegistry::AppActivityRegistry(
     const std::string& app_id,
     content::BrowserContext* browser_context) :
       app_id_(app_id),
       browser_context_(browser_context),
       unloaded_activity_proxy_(NULL) {}
 
 AppActivityRegistry::~AppActivityRegistry() {
   CHECK(activity_list_.empty());
   if (unloaded_activity_proxy_)
     ActivityManager::Get()->RemoveActivity(unloaded_activity_proxy_);
   DCHECK(!unloaded_activity_proxy_);
 }
 
 void AppActivityRegistry::RegisterAppActivity(AppActivity* app_activity) {
-  if (unloaded_activity_proxy_) {
-    // Since we add an application window, the activity isn't unloaded anymore.
-    ActivityManager::Get()->RemoveActivity(unloaded_activity_proxy_);
-    // With the removal the object should have been deleted and we should have
-    // been informed of the object's destruction.
-    DCHECK(!unloaded_activity_proxy_);
-  }
   // The same window should never be added twice.
   CHECK(std::find(activity_list_.begin(),
                   activity_list_.end(),
                   app_activity) == activity_list_.end());
   activity_list_.push_back(app_activity);
 }
 
 void AppActivityRegistry::UnregisterAppActivity(AppActivity* app_activity) {
   // It is possible that a detach gets called without ever being attached.
   std::vector<AppActivity*>::iterator it =
@@ skipping 12 matching lines @@
 
 AppActivity* AppActivityRegistry::GetAppActivityAt(size_t index) {
   if (index >= activity_list_.size())
     return NULL;
   return activity_list_[index];
 }
 
 void AppActivityRegistry::Unload() {
   CHECK(!unloaded_activity_proxy_);
   DCHECK(!activity_list_.empty());
-
   // In order to allow an entire application to unload we require that all of
   // its activities are marked as unloaded.
   for (std::vector<AppActivity*>::iterator it = activity_list_.begin();
        it != activity_list_.end(); ++it) {
     if ((*it)->GetCurrentState() != Activity::ACTIVITY_UNLOADED)
       return;
   }
 
   // Create an activity proxy which can be used to re-activate the app. Insert
   // the proxy then into the activity stream at the location of the (newest)
   // current activity.
-  unloaded_activity_proxy_ =
-      new AppActivityProxy(activity_list_[0]->GetActivityViewModel(), this);
+  unloaded_activity_proxy_ = new AppActivityProxy(GetMruActivity(), this);
   ActivityManager::Get()->AddActivity(unloaded_activity_proxy_);
-  // The new activity should be in the place of the most recently used app
-  // window. To get it there, we get the most recently used application window
-  // and place the proxy activities window in front or behind, so that when the
-  // activity disappears it takes its place.
-  MoveBeforeMruApplicationWindow(unloaded_activity_proxy_->GetWindow());
 
   // Unload the application. This operation will be asynchronous.
   if (!ExtensionsDelegate::Get(browser_context_)->UnloadApp(app_id_)) {
     while(!activity_list_.empty())
-      delete activity_list_.back();
+      Activity::CloseActivity(activity_list_.back());
   }
 }
 
 void AppActivityRegistry::ProxyDestroyed(AppActivityProxy* proxy) {
   DCHECK_EQ(unloaded_activity_proxy_, proxy);
   unloaded_activity_proxy_ = NULL;
   if (activity_list_.empty()) {
     AppRegistry::Get()->RemoveAppActivityRegistry(this);
     // |This| is gone now.
   }
 }
 
 void AppActivityRegistry::RestartApplication(AppActivityProxy* proxy) {
   DCHECK_EQ(unloaded_activity_proxy_, proxy);
-  // Restart the application.
+  // Restart the application. Note that the first created app window will make
+  // sure that the proxy gets deleted - after - the new activity got moved
+  // to the proxies activity location.
   ExtensionsDelegate::Get(browser_context_)->LaunchApp(app_id_);
-  // Delete the activity which will also remove the it from the ActivityManager.
-  delete unloaded_activity_proxy_;  // Will call ProxyDestroyed.
-  // After this call |this| might be gone if the app did not open a window yet.
 }
 
-void AppActivityRegistry::MoveBeforeMruApplicationWindow(aura::Window* window) {
+AppActivity* AppActivityRegistry::GetMruActivity() {

[oshima, 2014/09/04 16:39:23]

MruActivity may not be app activity right?

[Mr4D (OOO till 08-26), 2014/09/04 19:10:57]

Well - this is the MRU for *this* app (if there are more). So this is correct -
when looking at it in perspective of this app (which is the reason why it is a
class member of this class). Makes sense?

   DCHECK(activity_list_.size());
-  // TODO(skuhne): This needs to be changed to some kind of delegate which
-  // resides in the window manager.
+  // TODO(skuhne): This should be a query into the window manager.
   const aura::Window::Windows children =
-      activity_list_[0]->GetWindow()->parent()->children();;
+      activity_list_[0]->GetWindow()->parent()->children();
   // Find the first window in the container which is part of the application.
   for (aura::Window::Windows::const_iterator child_iterator = children.begin();
       child_iterator != children.end(); ++child_iterator) {
     for (std::vector<AppActivity*>::iterator app_iterator =
              activity_list_.begin();
          app_iterator != activity_list_.end(); ++app_iterator) {
-      if (*child_iterator == (*app_iterator)->GetWindow()) {
-        // Since "StackChildBelow" does not change the order if the window
-        // if the window is below - but not immediately behind - the target
-        // window, we re-stack both ways.
-        window->parent()->StackChildBelow(window, *child_iterator);
-        window->parent()->StackChildBelow(*child_iterator, window);
-        return;
-      }
+      if (*child_iterator == (*app_iterator)->GetWindow())
+        return *app_iterator;
     }
   }
   NOTREACHED() << "The application does not get tracked by the mru list";
+  return NULL;
 }
 
 }  // namespace athena