Android: Don't evict thumbnails for last visible tab on stop

chrome/browser/android/thumbnail/thumbnail_cache.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 "chrome/browser/android/thumbnail/thumbnail_cache.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 
+#include "base/android/application_status_listener.h"
 #include "base/android/path_utils.h"
 #include "base/big_endian.h"
 #include "base/files/file.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
@@ skipping 103 matching lines @@
       write_queue_max_size_(write_queue_max_size),
       use_approximation_thumbnail_(use_approximation_thumbnail),
       compression_tasks_count_(0),
       write_tasks_count_(0),
       read_in_progress_(false),
       cache_(default_cache_size),
       approximation_cache_(approximation_cache_size),
       ui_resource_provider_(NULL),
       weak_factory_(this) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  memory_pressure_.reset(new base::MemoryPressureListener(
+      base::Bind(&ThumbnailCache::OnMemoryPressure, base::Unretained(this))));
 }
 
 ThumbnailCache::~ThumbnailCache() {
   SetUIResourceProvider(NULL);
 }
 
 void ThumbnailCache::SetUIResourceProvider(
     ui::UIResourceProvider* ui_resource_provider) {
   if (ui_resource_provider_ == ui_resource_provider)
     return;
@@ skipping 294 matching lines @@
 }
 
 void ThumbnailCache::RemoveFromReadQueue(TabId tab_id) {
   TabIdList::iterator read_iter =
       std::find(read_queue_.begin(), read_queue_.end(), tab_id);
   if (read_iter != read_queue_.end())
     read_queue_.erase(read_iter);
 }
 
 void ThumbnailCache::OnUIResourcesWereEvicted() {
-  cache_.Clear();
-  approximation_cache_.Clear();
+  if (visible_ids_.empty()) {
+    cache_.Clear();
+    approximation_cache_.Clear();
+  } else {
+    TabId last_tab = visible_ids_.front();
+    std::unique_ptr<Thumbnail> thumbnail = cache_.Remove(last_tab);
+    cache_.Clear();
+    std::unique_ptr<Thumbnail> approximation =
+        approximation_cache_.Remove(last_tab);
+    approximation_cache_.Clear();
+
+    // Keep the thumbnail for app resume if it wasn't uploaded yet.
+    if (thumbnail.get() && !thumbnail->ui_resource_id())
+      cache_.Put(last_tab, std::move(thumbnail));
+    if (approximation.get() && !approximation->ui_resource_id())
+      approximation_cache_.Put(last_tab, std::move(approximation));
+  }
 }
 
 void ThumbnailCache::InvalidateCachedThumbnail(Thumbnail* thumbnail) {
   DCHECK(thumbnail);
   TabId tab_id = thumbnail->tab_id();
   cc::UIResourceId uid = thumbnail->ui_resource_id();
 
   Thumbnail* cached_thumbnail = cache_.Get(tab_id);
   if (cached_thumbnail && cached_thumbnail->ui_resource_id() == uid)
     cache_.Remove(tab_id);
@@ skipping 146 matching lines @@
   if (!compressed_data) {
     RemoveOnMatchedTimeStamp(tab_id, time_stamp);
     return;
   }
 
   Thumbnail* thumbnail = cache_.Get(tab_id);
   if (thumbnail) {
     if (thumbnail->time_stamp() != time_stamp)
       return;
     thumbnail->SetCompressedBitmap(compressed_data, content_size);
-    thumbnail->CreateUIResource();
+    // Don't upload the texture if we are being paused/stopped because
+    // the context will go away anyways.
+    if (base::android::ApplicationStatusListener::GetState() ==
+        base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES) {
+      thumbnail->CreateUIResource();
+    }
   }
   WriteThumbnailIfNecessary(tab_id, std::move(compressed_data), scale,
                             content_size);
 }
 
 namespace {
 
 bool ReadFromFile(base::File& file,
                   gfx::Size* out_content_size,
                   float* out_scale,
@@ skipping 275 matching lines @@
   dst_bitmap.eraseColor(0);
   SkAutoLockPixels dst_bitmap_lock(dst_bitmap);
 
   SkCanvas canvas(dst_bitmap);
   canvas.scale(new_scale, new_scale);
   canvas.drawBitmap(bitmap, 0, 0, NULL);
   dst_bitmap.setImmutable();
 
   return std::make_pair(dst_bitmap, new_scale * scale);
 }
+
+void ThumbnailCache::OnMemoryPressure(
+    base::MemoryPressureListener::MemoryPressureLevel level) {
+  if (level == base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
+    cache_.Clear();
+    approximation_cache_.Clear();
+  }
+}