Implementing TabManager extensions API Discard Function.

chrome/browser/memory/tab_manager.cc

 // Copyright (c) 2012 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/memory/tab_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 276 matching lines @@
   int index = FindTabStripModelById(target_web_contents_id, &model);
 
   if (index == -1)
     return nullptr;
 
   VLOG(1) << "Discarding tab " << index << " id " << target_web_contents_id;
 
   return DiscardWebContentsAt(index, model);
 }
 
+WebContents* TabManager::DiscardTabByExtension(content::WebContents* contents) {
+  if (contents)
+    return DiscardTabById(reinterpret_cast<int64_t>(contents));
+
+  return DiscardTabImpl();
+}
+
 void TabManager::LogMemoryAndDiscardTab() {
   LogMemory("Tab Discards Memory details",
             base::Bind(&TabManager::PurgeMemoryAndDiscardTab));
 }
 
 void TabManager::LogMemory(const std::string& title,
                            const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   OomMemoryDetails::Log(title, callback);
 }
@@ skipping 527 matching lines @@
   task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&TabManager::DoChildProcessDispatch,
                  weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(kRendererNotificationDelayInSeconds));
 }
 
 // TODO(jamescook): This should consider tabs with references to other tabs,
 // such as tabs created with JavaScript window.open(). Potentially consider
 // discarding the entire set together, or use that in the priority computation.
-bool TabManager::DiscardTabImpl() {
+content::WebContents* TabManager::DiscardTabImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TabStatsList stats = GetTabStats();
 
   if (stats.empty())
-    return false;
+    return nullptr;
   // Loop until a non-discarded tab to kill is found.
   for (TabStatsList::const_reverse_iterator stats_rit = stats.rbegin();
        stats_rit != stats.rend(); ++stats_rit) {
     int64_t least_important_tab_id = stats_rit->tab_contents_id;
-    if (CanDiscardTab(least_important_tab_id) &&
-        DiscardTabById(least_important_tab_id))
-      return true;
+    if (CanDiscardTab(least_important_tab_id)) {
+      WebContents* new_contents = DiscardTabById(least_important_tab_id);
+      if (new_contents)
+        return new_contents;
+    }
   }
-  return false;
+  return nullptr;
 }
 
 // Check the variation parameter to see if a tab can be discarded only once or
 // multiple times.
 // Default is to only discard once per tab.
 bool TabManager::CanOnlyDiscardOnce() {
 #if defined(OS_WIN) || defined(OS_MACOSX)
   // On Windows and MacOS, default to discarding only once unless otherwise
   // specified by the variation parameter.
   // TODO(georgesak): Add Linux when automatic discarding is enabled for that
@@ skipping 39 matching lines @@
 void TabManager::RemoveObserver(TabManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void TabManager::OnDiscardedStateChange(content::WebContents* contents,
                                         bool is_discarded) {
   FOR_EACH_OBSERVER(TabManagerObserver, observers_,
                     OnDiscardedStateChange(contents, is_discarded));
 }
 
+void TabManager::set_minimum_protection_time_for_tests(
+    base::TimeDelta minimum_protection_time) {
+  minimum_protection_time_ = minimum_protection_time;
+}
+
 void TabManager::OnAutoDiscardableStateChange(content::WebContents* contents,
                                               bool is_auto_discardable) {
   FOR_EACH_OBSERVER(
       TabManagerObserver, observers_,
       OnAutoDiscardableStateChange(contents, is_auto_discardable));
 }
 
 bool TabManager::IsTabAutoDiscardable(content::WebContents* contents) const {
   return GetWebContentsData(contents)->IsAutoDiscardable();
 }
 
 void TabManager::SetTabAutoDiscardableState(content::WebContents* contents,
                                             bool state) {
   GetWebContentsData(contents)->SetAutoDiscardableState(state);
 }
 
 }  // namespace memory