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 49 matching lines @@
   size_t max_running_activities = 5;
   switch (current_memory_pressure_) {
     case MEMORY_PRESSURE_UNKNOWN:
       // If we do not know how much memory we have we assume that it must be a
       // high consumption.
       // Fallthrough.
     case MEMORY_PRESSURE_HIGH:
       max_running_activities = 5;
       break;
     case MEMORY_PRESSURE_CRITICAL:
-      max_running_activities = 0;
+      max_running_activities = 1 + (in_splitview_mode_ ? 1 : 0);
       break;
     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
   // 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);
+    max_activities = max_running_activities;
 
   // 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);
+      }
     }
 
     // See which index we should handle next.
     if (activity_order_changed_) {
       activity_order_changed_ = false;
       index = 0;
     } else {
       ++index;
     }
   }
@@ skipping 94 matching lines @@
 }
 
 ResourceManager::ResourceManager() {}
 
 ResourceManager::~ResourceManager() {
   DCHECK(instance);
   instance = NULL;
 }
 
 }  // namespace athena