Adding overview / layer framework to Activities so that unloaded / sleeping activities can be shown…

athena/resource_manager/resource_manager_impl.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/resource_manager/public/resource_manager.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "athena/activity/public/activity.h"
@@ skipping 158 matching lines @@
   // Remember that the activity order has changed.
   activity_order_changed_ = true;
 }
 
 void ResourceManagerImpl::OnOverviewModeEnter() {
   in_overview_mode_ = true;
 }
 
 void ResourceManagerImpl::OnOverviewModeExit() {
   in_overview_mode_ = false;
-  // Reorder the activities.
+  // Reorder the activities and manage the resources again since an order change
+  // might have caused a visibility change.
   UpdateActivityOrder();
+  ManageResource();
 }
 
 void ResourceManagerImpl::OnSplitViewModeEnter() {
   // Re-apply the memory pressure to make sure enough items are visible.
   in_splitview_mode_ = true;
   ManageResource();
 }
 
 
 void ResourceManagerImpl::OnSplitViewModeExit() {
@@ skipping 61 matching lines @@
     case MEMORY_PRESSURE_MODERATE:
       max_running_activities = 7;
       break;
     case MEMORY_PRESSURE_LOW:
       // This doesn't really matter. We do not change anything but turning
       // activities visible.
       max_running_activities = 10000;
       break;
   }
 
-  // The first n activities should be trated as "visible", means they updated
+  // The first n activities should be treated as "visible", means they updated
   // in overview mode and will keep their layer resources for faster switch
   // times. Usually we use |kMaxVisibleActivities| items, but when the memory
   // pressure gets critical we only hold as many as are really visible.
   size_t max_activities = kMaxVisibleActivities;
   if (current_memory_pressure_ == MEMORY_PRESSURE_CRITICAL)
     max_activities = 1 + (in_splitview_mode_ ? 1 : 0);
 
   // Restart and / or bail if the order of activities changes due to our calls.
   activity_order_changed_ = false;
 
   // Change the visibility of our activities in a pre-processing step. This is
   // required since it might change the order/number of activities.
   size_t index = 0;
   while (index < activity_list_.size()) {
     Activity* activity = activity_list_[index];
     Activity::ActivityState state = activity->GetCurrentState();
 
     // The first |kMaxVisibleActivities| entries should be visible, all others
     // invisible or at a lower activity state.
     if (index < max_activities ||
         (state == Activity::ACTIVITY_INVISIBLE ||
          state == Activity::ACTIVITY_VISIBLE)) {
       Activity::ActivityState visiblity_state =
           index < max_activities ? Activity::ACTIVITY_VISIBLE :
                                    Activity::ACTIVITY_INVISIBLE;
       // Only change the state when it changes. Note that when the memory
       // pressure is critical, only the primary activities (1 or 2) are made
-      // visible. Furthermore, in relaxed mode we only want to make visible.
+      // visible. Furthermore, in relaxed mode we only want to turn visible,
+      // never invisible.
       if (visiblity_state != state &&
           (current_memory_pressure_ != MEMORY_PRESSURE_LOW ||
-           visiblity_state == Activity::ACTIVITY_VISIBLE))
+           visiblity_state == Activity::ACTIVITY_VISIBLE)) {
         activity->SetCurrentState(visiblity_state);
+        // If we turned an activity invisible, we should not at the same time
+        // throw an activity out of memory. Thus we grant one more invisible
+        // Activity in that case.
+        if (visiblity_state == Activity::ACTIVITY_INVISIBLE)
+          max_running_activities++;
+      }
     }
 
     // See which index we should handle next.
     if (activity_order_changed_) {
       activity_order_changed_ = false;
       index = 0;
     } else {
       ++index;
     }
   }
 
   // No need to remove anything.
   if (current_memory_pressure_ == MEMORY_PRESSURE_LOW)
     return;
-
+  // TODO(skuhne): Do not release too many activities in short succession.
+  // since it takes time to release resources. As such the time of last call
+  // should be remembered and if called to early we should exit early.
   // Check if/which activity we want to unload.
   Activity* oldest_media_activity = NULL;
   std::vector<Activity*> unloadable_activities;
   for (std::vector<Activity*>::iterator it = activity_list_.begin();
        it != activity_list_.end(); ++it) {
     Activity::ActivityState state = (*it)->GetCurrentState();
     // The activity should neither be unloaded nor visible.
     if (state != Activity::ACTIVITY_UNLOADED &&
         state != Activity::ACTIVITY_VISIBLE) {
       if ((*it)->GetMediaState() == Activity::ACTIVITY_MEDIA_STATE_NONE) {
@@ skipping 79 matching lines @@
 }
 
 ResourceManager::ResourceManager() {}
 
 ResourceManager::~ResourceManager() {
   DCHECK(instance);
   instance = NULL;
 }
 
 }  // namespace athena