Use TabStripModelObserver's new API in chrome/browser/resource_coordinator

Replace old API with new API. This CL is a refactor
ans has no intended behavior change.

Bug: 842194
Change-Id: Iac5ac3946c8590d5983c93d14a725d7de670311a
Reviewed-on: https://chromium-review.googlesource.com/1179120Reviewed-by: Chris Hamilton <chrisha@chromium.org>
Commit-Queue: Sang Woo Ko <sangwoo108@chromium.org>
Cr-Commit-Position: refs/heads/master@{#584967}

chrome/browser/resource_coordinator/tab_activity_watcher.cc

@@ -424,36 +424,45 @@ void TabActivityWatcher::OnBrowserSetLastActive(Browser* browser) {
     web_contents_data->TabWindowActivated();
 }
 
-void TabActivityWatcher::TabInsertedAt(TabStripModel* tab_strip_model,
-                                       content::WebContents* contents,
-                                       int index,
-                                       bool foreground) {
-  // Ensure the WebContentsData is created to observe this WebContents since it
-  // may represent a newly created tab.
-  WebContentsData::CreateForWebContents(contents);
-  WebContentsData::FromWebContents(contents)->TabInserted(foreground);
-}
-
-void TabActivityWatcher::TabDetachedAt(content::WebContents* contents,
-                                       int index,
-                                       bool was_active) {
-  WebContentsData::FromWebContents(contents)->TabDetached();
-}
-
-void TabActivityWatcher::TabReplacedAt(TabStripModel* tab_strip_model,
-                                       content::WebContents* old_contents,
-                                       content::WebContents* new_contents,
-                                       int index) {
+void TabActivityWatcher::OnTabStripModelChanged(
+    TabStripModel* tab_strip_model,
+    const TabStripModelChange& change,
+    const TabStripSelectionChange& selection) {
+  switch (change.type()) {
+    case TabStripModelChange::kInserted: {
+      for (const auto& delta : change.deltas()) {
+        // Ensure the WebContentsData is created to observe this WebContents
+        // since it may represent a newly created tab.
+        WebContentsData::CreateForWebContents(delta.insert.contents);
+        WebContentsData::FromWebContents(delta.insert.contents)
+            ->TabInserted(selection.new_contents == delta.insert.contents);
+      }
+      break;
+    }
+    case TabStripModelChange::kRemoved: {
+      for (const auto& delta : change.deltas())
+        WebContentsData::FromWebContents(delta.remove.contents)->TabDetached();
+      break;
+    }
+    case TabStripModelChange::kReplaced: {
+      for (const auto& delta : change.deltas()) {
         WebContentsData* old_web_contents_data =
-      WebContentsData::FromWebContents(old_contents);
+            WebContentsData::FromWebContents(delta.replace.old_contents);
         old_web_contents_data->WasReplaced();
 
-  // Ensure the WebContentsData is created to observe this WebContents since it
-  // likely hasn't been inserted into a tabstrip before.
-  WebContentsData::CreateForWebContents(new_contents);
+        // Ensure the WebContentsData is created to observe this WebContents
+        // since it likely hasn't been inserted into a tabstrip before.
+        WebContentsData::CreateForWebContents(delta.replace.new_contents);
 
-  WebContentsData::FromWebContents(new_contents)
+        WebContentsData::FromWebContents(delta.replace.new_contents)
             ->DidReplace(*old_web_contents_data);
+      }
+      break;
+    }
+    case TabStripModelChange::kMoved:
+    case TabStripModelChange::kSelectionOnly:
+      break;
+  }
 }
 
 void TabActivityWatcher::TabPinnedStateChanged(TabStripModel* tab_strip_model,

chrome/browser/resource_coordinator/tab_activity_watcher.h

@@ -54,17 +54,10 @@ class TabActivityWatcher : public BrowserListObserver,
   void OnBrowserSetLastActive(Browser* browser) override;
 
   // TabStripModelObserver:
-  void TabInsertedAt(TabStripModel* tab_strip_model,
-                     content::WebContents* contents,
-                     int index,
-                     bool foreground) override;
-  void TabDetachedAt(content::WebContents* contents,
-                     int index,
-                     bool was_active) override;
-  void TabReplacedAt(TabStripModel* tab_strip_model,
-                     content::WebContents* old_contents,
-                     content::WebContents* new_contents,
-                     int index) override;
+  void OnTabStripModelChanged(
+      TabStripModel* tab_strip_model,
+      const TabStripModelChange& change,
+      const TabStripSelectionChange& selection) override;
   void TabPinnedStateChanged(TabStripModel* tab_strip_model,
                              content::WebContents* contents,
                              int index) override;

chrome/browser/resource_coordinator/tab_lifecycle_unit_source.cc

@@ -154,7 +154,14 @@ void TabLifecycleUnitSource::UpdateFocusedTab() {
   TabLifecycleUnit* focused_lifecycle_unit =
       focused_web_contents ? GetTabLifecycleUnit(focused_web_contents)
                            : nullptr;
-  DCHECK(!focused_web_contents || focused_lifecycle_unit);
+
+  // TODO(sangwoo.ko) We are refactoring TabStripModel API and this is
+  // workaround to avoid DCHECK failure on Chromium os. This DCHECK is supposing
+  // that OnTabInserted() is always called before OnBrowserSetLastActive is
+  // called but it's not. After replacing old API use in BrowserView,
+  // restore this to DCHECK(!focused_web_contents || focused_lifecycle_unit);
+  // else case will be handled by following OnTabInserted().
+  if (!focused_web_contents || focused_lifecycle_unit)
     UpdateFocusedTabTo(focused_lifecycle_unit);
 }
 
@@ -169,9 +176,8 @@ void TabLifecycleUnitSource::UpdateFocusedTabTo(
   focused_lifecycle_unit_ = new_focused_lifecycle_unit;
 }
 
-void TabLifecycleUnitSource::TabInsertedAt(TabStripModel* tab_strip_model,
+void TabLifecycleUnitSource::OnTabInserted(TabStripModel* tab_strip_model,
                                            content::WebContents* contents,
-                                           int index,
                                            bool foreground) {
   TabLifecycleUnit* lifecycle_unit = GetTabLifecycleUnit(contents);
   if (lifecycle_unit) {
@@ -197,9 +203,7 @@ void TabLifecycleUnitSource::TabInsertedAt(TabStripModel* tab_strip_model,
   }
 }
 
-void TabLifecycleUnitSource::TabDetachedAt(content::WebContents* contents,
-                                           int index,
-                                           bool was_active) {
+void TabLifecycleUnitSource::OnTabDetached(content::WebContents* contents) {
   TabLifecycleUnit* lifecycle_unit = GetTabLifecycleUnit(contents);
   DCHECK(lifecycle_unit);
   if (focused_lifecycle_unit_ == lifecycle_unit)
@@ -207,18 +211,8 @@ void TabLifecycleUnitSource::TabDetachedAt(content::WebContents* contents,
   lifecycle_unit->SetTabStripModel(nullptr);
 }
 
-void TabLifecycleUnitSource::ActiveTabChanged(
-    content::WebContents* old_contents,
-    content::WebContents* new_contents,
-    int index,
-    int reason) {
-  UpdateFocusedTab();
-}
-
-void TabLifecycleUnitSource::TabReplacedAt(TabStripModel* tab_strip_model,
-                                           content::WebContents* old_contents,
-                                           content::WebContents* new_contents,
-                                           int index) {
+void TabLifecycleUnitSource::OnTabReplaced(content::WebContents* old_contents,
+                                           content::WebContents* new_contents) {
   auto* old_contents_holder =
       TabLifecycleUnitHolder::FromWebContents(old_contents);
   DCHECK(old_contents_holder);
@@ -233,6 +227,37 @@ void TabLifecycleUnitSource::TabReplacedAt(TabStripModel* tab_strip_model,
   new_contents_holder->lifecycle_unit()->SetWebContents(new_contents);
 }
 
+void TabLifecycleUnitSource::OnTabStripModelChanged(
+    TabStripModel* tab_strip_model,
+    const TabStripModelChange& change,
+    const TabStripSelectionChange& selection) {
+  switch (change.type()) {
+    case TabStripModelChange::kInserted: {
+      for (const auto& delta : change.deltas()) {
+        OnTabInserted(tab_strip_model, delta.insert.contents,
+                      selection.new_contents == delta.insert.contents);
+      }
+      break;
+    }
+    case TabStripModelChange::kRemoved: {
+      for (const auto& delta : change.deltas())
+        OnTabDetached(delta.remove.contents);
+      break;
+    }
+    case TabStripModelChange::kReplaced: {
+      for (const auto& delta : change.deltas())
+        OnTabReplaced(delta.replace.old_contents, delta.replace.new_contents);
+      break;
+    }
+    case TabStripModelChange::kMoved:
+    case TabStripModelChange::kSelectionOnly:
+      break;
+  }
+
+  if (selection.active_tab_changed() && !tab_strip_model->empty())
+    UpdateFocusedTab();
+}
+
 void TabLifecycleUnitSource::TabChangedAt(content::WebContents* contents,
                                           int index,
                                           TabChangeType change_type) {

chrome/browser/resource_coordinator/tab_lifecycle_unit_source.h

@@ -111,22 +111,20 @@ class TabLifecycleUnitSource : public BrowserListObserver,
   // TabInsertedAt() is called.
   void UpdateFocusedTabTo(TabLifecycleUnit* new_focused_lifecycle_unit);
 
-  // TabStripModelObserver:
-  void TabInsertedAt(TabStripModel* tab_strip_model,
+  // Methods called by OnTabStripModelChanged()
+  void OnTabInserted(TabStripModel* tab_strip_model,
                      content::WebContents* contents,
-                     int index,
-                     bool foreground) override;
-  void TabDetachedAt(content::WebContents* contents,
-                     int index,
-                     bool was_active) override;
-  void ActiveTabChanged(content::WebContents* old_contents,
-                        content::WebContents* new_contents,
-                        int index,
-                        int reason) override;
-  void TabReplacedAt(TabStripModel* tab_strip_model,
-                     content::WebContents* old_contents,
-                     content::WebContents* new_contents,
-                     int index) override;
+                     bool foreground);
+  void OnTabDetached(content::WebContents* contents);
+  void OnTabReplaced(content::WebContents* old_contents,
+                     content::WebContents* new_contents);
+
+  // TabStripModelObserver:
+  void OnTabStripModelChanged(
+      TabStripModel* tab_strip_model,
+      const TabStripModelChange& change,
+      const TabStripSelectionChange& selection) override;
+
   void TabChangedAt(content::WebContents* contents,
                     int index,
                     TabChangeType change_type) override;

chrome/browser/resource_coordinator/tab_manager.cc

@@ -546,10 +546,8 @@ void TabManager::OnMemoryPressure(
   // calling PurgeBrowserMemory() before CRITICAL is reached.
 }
 
-void TabManager::ActiveTabChanged(content::WebContents* old_contents,
-                                  content::WebContents* new_contents,
-                                  int index,
-                                  int reason) {
+void TabManager::OnActiveTabChanged(content::WebContents* old_contents,
+                                    content::WebContents* new_contents) {
   // An active tab is not purged.
   // Calling GetWebContentsData() early ensures that the WebContentsData is
   // created for |new_contents|, which |stats_collector_| expects.
@@ -571,12 +569,10 @@ void TabManager::ActiveTabChanged(content::WebContents* old_contents,
   ResumeTabNavigationIfNeeded(new_contents);
 }
 
-void TabManager::TabInsertedAt(TabStripModel* tab_strip_model,
-                               content::WebContents* contents,
-                               int index,
+void TabManager::OnTabInserted(content::WebContents* contents,
                                bool foreground) {
   // Only interested in background tabs, as foreground tabs get taken care of by
-  // ActiveTabChanged.
+  // OnActiveTabChanged.
   if (foreground)
     return;
 
@@ -588,11 +584,24 @@ void TabManager::TabInsertedAt(TabStripModel* tab_strip_model,
       GetTimeToPurge(min_time_to_purge_, max_time_to_purge_));
 }
 
-void TabManager::TabReplacedAt(TabStripModel* tab_strip_model,
-                               content::WebContents* old_contents,
-                               content::WebContents* new_contents,
-                               int index) {
-  WebContentsData::CopyState(old_contents, new_contents);
+void TabManager::OnTabStripModelChanged(
+    TabStripModel* tab_strip_model,
+    const TabStripModelChange& change,
+    const TabStripSelectionChange& selection) {
+  if (change.type() == TabStripModelChange::kInserted) {
+    for (const auto& delta : change.deltas()) {
+      OnTabInserted(delta.insert.contents,
+                    delta.insert.contents == selection.new_contents);
+    }
+  } else if (change.type() == TabStripModelChange::kReplaced) {
+    for (const auto& delta : change.deltas()) {
+      WebContentsData::CopyState(delta.replace.old_contents,
+                                 delta.replace.new_contents);
+    }
+  }
+
+  if (selection.active_tab_changed() && !tab_strip_model->empty())
+    OnActiveTabChanged(selection.old_contents, selection.new_contents);
 }
 
 void TabManager::OnStartTracking(content::WebContents* web_contents,

chrome/browser/resource_coordinator/tab_manager.h

@@ -311,19 +311,16 @@ class TabManager : public LifecycleUnitObserver,
   void OnMemoryPressure(
       base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
 
+  // Methods called by OnTabStripModelChanged()
+  void OnActiveTabChanged(content::WebContents* old_contents,
+                          content::WebContents* new_contents);
+  void OnTabInserted(content::WebContents* contents, bool foreground);
+
   // TabStripModelObserver:
-  void ActiveTabChanged(content::WebContents* old_contents,
-                        content::WebContents* new_contents,
-                        int index,
-                        int reason) override;
-  void TabInsertedAt(TabStripModel* tab_strip_model,
-                     content::WebContents* contents,
-                     int index,
-                     bool foreground) override;
-  void TabReplacedAt(TabStripModel* tab_strip_model,
-                     content::WebContents* old_contents,
-                     content::WebContents* new_contents,
-                     int index) override;
+  void OnTabStripModelChanged(
+      TabStripModel* tab_strip_model,
+      const TabStripModelChange& change,
+      const TabStripSelectionChange& selection) override;
 
   // TabLoadTracker::Observer:
   void OnStartTracking(content::WebContents* web_contents,

chrome/browser/resource_coordinator/tab_manager_unittest.cc

@@ -632,9 +632,7 @@ TEST_F(TabManagerTest, OnDelayedTabSelected) {
   EXPECT_TRUE(tab_manager_->IsNavigationDelayedForTest(nav_handle3_.get()));
 
   // Simulate selecting tab 3, which should start loading immediately.
-  tab_manager_->ActiveTabChanged(
-      contents1_.get(), contents3_.get(), 2,
-      TabStripModelObserver::CHANGE_REASON_USER_GESTURE);
+  tab_manager_->OnActiveTabChanged(contents1_.get(), contents3_.get());
 
   EXPECT_TRUE(tab_manager_->IsTabLoadingForTest(contents1_.get()));
   EXPECT_TRUE(tab_manager_->IsTabLoadingForTest(contents3_.get()));