Move the notion of current Tab from TabModel to WebStateList.

ios/shared/chrome/browser/tabs/web_state_list.mm

 // Copyright 2017 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.
 
 #import "ios/shared/chrome/browser/tabs/web_state_list.h"
 
+#include <algorithm>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #import "ios/shared/chrome/browser/tabs/web_state_list_observer.h"
 #import "ios/shared/chrome/browser/tabs/web_state_list_order_controller.h"
 #import "ios/web/public/navigation_manager.h"
 #import "ios/web/public/web_state/web_state.h"
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
@@ skipping 81 matching lines @@
 WebStateList::WebStateList(WebStateOwnership ownership)
     : web_state_ownership_(ownership),
       order_controller_(base::MakeUnique<WebStateListOrderController>(this)) {}
 
 WebStateList::~WebStateList() = default;
 
 bool WebStateList::ContainsIndex(int index) const {
   return 0 <= index && index < count();
 }
 
+web::WebState* WebStateList::GetActiveWebState() const {
+  if (active_index_ != kInvalidIndex)
+    return GetWebStateAt(active_index_);
+  return nullptr;
+}
+
 web::WebState* WebStateList::GetWebStateAt(int index) const {
   DCHECK(ContainsIndex(index));
   return web_state_wrappers_[index]->web_state();
 }
 
 int WebStateList::GetIndexOfWebState(const web::WebState* web_state) const {
   for (int index = 0; index < count(); ++index) {
     if (web_state_wrappers_[index]->web_state() == web_state)
       return index;
   }
@@ skipping 25 matching lines @@
 
 void WebStateList::InsertWebState(int index,
                                   web::WebState* web_state,
                                   web::WebState* opener) {
   DCHECK(ContainsIndex(index) || index == count());
   web_state_wrappers_.insert(
       web_state_wrappers_.begin() + index,
       base::MakeUnique<WebStateWrapper>(web_state,
                                         web_state_ownership_ == WebStateOwned));
 
+  if (active_index_ >= index)
+    ++active_index_;
+
   if (opener)
     SetOpenerOfWebStateAt(index, opener);
 
   for (auto& observer : observers_)
     observer.WebStateInsertedAt(this, web_state, index);
 }
 
 void WebStateList::AppendWebState(ui::PageTransition transition,
                                   web::WebState* web_state,
                                   web::WebState* opener) {
@@ skipping 10 matching lines @@
   if (from_index == to_index)
     return;
 
   std::unique_ptr<WebStateWrapper> web_state_wrapper =
       std::move(web_state_wrappers_[from_index]);
   web::WebState* web_state = web_state_wrapper->web_state();
   web_state_wrappers_.erase(web_state_wrappers_.begin() + from_index);
   web_state_wrappers_.insert(web_state_wrappers_.begin() + to_index,
                              std::move(web_state_wrapper));
 
+  if (active_index_ == from_index) {
+    active_index_ = to_index;
+  } else {
+    int min = std::min(from_index, to_index);
+    int max = std::max(from_index, to_index);
+    int delta = from_index < to_index ? -1 : +1;
+    if (min <= active_index_ && active_index_ <= max)
+      active_index_ += delta;
+  }
+
   for (auto& observer : observers_)
     observer.WebStateMoved(this, web_state, from_index, to_index);
 }
 
 web::WebState* WebStateList::ReplaceWebStateAt(int index,
                                                web::WebState* web_state,
                                                web::WebState* opener) {
   DCHECK(ContainsIndex(index));
   FixOpenersReferencing(index);
 
   auto& web_state_wrapper = web_state_wrappers_[index];
   web::WebState* old_web_state = web_state_wrapper->ReplaceWebState(web_state);
 
   if (opener && opener != old_web_state)
     SetOpenerOfWebStateAt(index, opener);
 
   for (auto& observer : observers_)
     observer.WebStateReplacedAt(this, old_web_state, web_state, index);
 
   return old_web_state;
 }
 
 void WebStateList::DetachWebStateAt(int index) {
   DCHECK(ContainsIndex(index));
   FixOpenersReferencing(index);
 
+  int new_active_index = order_controller_->DetermineNewActiveIndex(index);
+
   web::WebState* web_state = web_state_wrappers_[index]->web_state();

[rohitrao (ping after 24h), 2017/02/22 15:13:43]

What keeps ownership of this object so that it doesn't get destroyed when the
next line runs?

[sdefresne, 2017/02/23 15:43:48]

That's a really good remark. Fixed by
https://codereview.chromium.org/2710183003/.

   web_state_wrappers_.erase(web_state_wrappers_.begin() + index);
 
+  // Update the active index to prevent observer from seeing an invalid WebState
+  // as the active one but only send the WebStateActivatedAt notification after
+  // the WebStateDetachedAt one.
+  bool active_web_state_was_closed = (index == active_index_);
+  if (active_index_ > index)

[marq (ping after 24h), 2017/02/21 17:23:11]

Use {} if there's an else clause.

[sdefresne, 2017/02/21 17:29:29]

I checked the style guide [1] and it does not say to use {} if there is an else
clause. It says that if one of the two parts of the conditional uses braces,
then both need to use them. It also says that single line conditional may omit
braces. It understand the conjunction of both statement as meaning that you can
omit them in both part of the conditional if they are both single lines.

[1]: https://google.github.io/styleguide/cppguide.html#Conditionals

+    --active_index_;
+  else if (active_index_ == index)
+    active_index_ = new_active_index;
+
   for (auto& observer : observers_)
     observer.WebStateDetachedAt(this, web_state, index);
+
+  if (active_web_state_was_closed)
+    NotifyIfActiveWebStateChanged(web_state, false);
+}
+
+void WebStateList::ActivateWebStateAt(int index) {
+  DCHECK(ContainsIndex(index));
+  web::WebState* old_web_state = GetActiveWebState();
+  active_index_ = index;
+  NotifyIfActiveWebStateChanged(old_web_state, true);
 }
 
 void WebStateList::AddObserver(WebStateListObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WebStateList::RemoveObserver(WebStateListObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WebStateList::FixOpenersReferencing(int index) {
   web::WebState* old_web_state = web_state_wrappers_[index]->web_state();
   for (auto& web_state_wrapper : web_state_wrappers_) {
     if (web_state_wrapper->opener() == old_web_state)
       web_state_wrapper->SetOpener(nullptr);
   }
 }
 
+void WebStateList::NotifyIfActiveWebStateChanged(web::WebState* old_web_state,
+                                                 bool user_action) {
+  web::WebState* new_web_state = GetActiveWebState();
+  if (old_web_state == new_web_state)
+    return;
+
+  for (auto& observer : observers_) {
+    observer.WebStateActivatedAt(this, old_web_state, new_web_state,
+                                 active_index_, user_action);
+  }
+}
+
 int WebStateList::GetIndexOfNthWebStateOpenedBy(const web::WebState* opener,
                                                 int start_index,
                                                 bool use_group,
                                                 int n) const {
   DCHECK_GT(n, 0);
   if (!opener || !ContainsIndex(start_index) || start_index == INT_MAX)
     return kInvalidIndex;
 
   const int opener_navigation_index =
       use_group ? opener->GetNavigationManager()->GetCurrentItemIndex() : -1;
 
   int found_index = kInvalidIndex;
   for (int index = start_index + 1; index < count() && n; ++index) {
     if (web_state_wrappers_[index]->WasOpenedBy(opener, opener_navigation_index,
                                                 use_group)) {
       found_index = index;
       --n;
     } else if (found_index != kInvalidIndex) {
       return found_index;
     }
   }
 
   return found_index;
 }
 
 // static
 const int WebStateList::kInvalidIndex;