[ios] WebStateList owns all WebState it manages.

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

 // 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.
 
 #ifndef IOS_SHARED_CHROME_BROWSER_TABS_WEB_STATE_LIST_H_
 #define IOS_SHARED_CHROME_BROWSER_TABS_WEB_STATE_LIST_H_
 
 #include <memory>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "ui/base/page_transition_types.h"
 
 class WebStateListDelegate;
 class WebStateListObserver;
 class WebStateListOrderController;
 struct WebStateOpener;
 
 namespace web {
 class WebState;
 }
 
-// Manages a list of WebStates. May owns the WebState depending on the ownership
-// setting (initialised during construction, should eventually always be "owned"
-// once ownership of Tab is sane, see http://crbug.com/546222 for progress).
+// Manages a list of WebStates.
 class WebStateList {
  public:
-  enum WebStateOwnership {
-    WebStateBorrowed,
-    WebStateOwned,
-  };
-
-  WebStateList(WebStateListDelegate* delegate, WebStateOwnership ownership);
+  explicit WebStateList(WebStateListDelegate* delegate);

[rohitrao (ping after 24h), 2017/04/03 17:49:35]

This is potentially a change that could be split out into a separate CL.  (We
could switch all callers to use Owned in this CL, then remove all of the
Borrowed code in a followup.)

[sdefresne, 2017/04/04 13:47:57]

When rebasing, I had conflict with code that added new uses of WebStateList (in
unit tests). As I'm changing the API and behaviour of WebStateList, I prefer to
do it in a single CL to avoid either:
1. supporting non-owning WebStateList with a CloseWebStateAt method (weird),
2. chasing DCHECK failures in tests that tries to create non-owning
WebStateList.

Unless you strongly prefer this separation, I'd like to not do it.

   ~WebStateList();
 
   // Returns whether the model is empty or not.
   bool empty() const { return web_state_wrappers_.empty(); }
 
   // Returns the number of WebStates in the model.
   int count() const { return static_cast<int>(web_state_wrappers_.size()); }
 
   // Returns the index of the currently active WebState, or kInvalidIndex if
   // there are no active WebState.
@@ skipping 32 matching lines @@
 
   // Returns the index of the last WebState in the sequence of WebStates opened
   // from the specified WebState after |start_index|, or kInvalidIndex if there
   // are no such WebState. If |use_group| is true, the opener's navigation index
   // is used to detect navigation changes within the same session.
   int GetIndexOfLastWebStateOpenedBy(const web::WebState* opener,
                                      int start_index,
                                      bool use_group) const;
 
   // Inserts the specified WebState at the specified index.
-  void InsertWebState(int index, web::WebState* web_state);
+  void InsertWebState(int index, std::unique_ptr<web::WebState> web_state);
 
   // Inserts the specified WebState at the best position in the WebStateList
   // given the specified transition, opener, etc. It defaults to inserting the
   // WebState at the end of the list.
   void AppendWebState(ui::PageTransition transition,
-                      web::WebState* web_state,
+                      std::unique_ptr<web::WebState> web_state,
                       WebStateOpener opener);
 
   // Moves the WebState at the specified index to another index.
   void MoveWebStateAt(int from_index, int to_index);
 
   // Replaces the WebState at the specified index with new WebState. Returns
   // the old WebState at that index to the caller (abandon ownership of the
   // returned WebState).
-  web::WebState* ReplaceWebStateAt(int index,
-                                   web::WebState* web_state) WARN_UNUSED_RESULT;
+  std::unique_ptr<web::WebState> ReplaceWebStateAt(
+      int index,
+      std::unique_ptr<web::WebState> web_state);
 
   // Detaches the WebState at the specified index. Returns the detached WebState
   // to the caller (abandon ownership of the returned WebState).
-  web::WebState* DetachWebStateAt(int index) WARN_UNUSED_RESULT;
+  std::unique_ptr<web::WebState> DetachWebStateAt(int index);
+
+  // Closes and destroys the WebState at the specified index.
+  void CloseWebStateAt(int index);
+
+  // Closes and destroys all WebStates.
+  void CloseAllWebStates();
 
   // Makes the WebState at the specified index the active WebState.
   void ActivateWebStateAt(int index);
 
   // Adds an observer to the model.
   void AddObserver(WebStateListObserver* observer);
 
   // Removes an observer from the model.
   void RemoveObserver(WebStateListObserver* observer);
 
@@ skipping 17 matching lines @@
   // opener's navigation index is used to detect navigation changes within the
   // same session.
   int GetIndexOfNthWebStateOpenedBy(const web::WebState* opener,
                                     int start_index,
                                     bool use_group,
                                     int n) const;
 
   // The WebStateList delegate.
   WebStateListDelegate* delegate_;
 
-  // Whether this WebStateList owns the WebState it hosts.
-  // TODO(crbug.com/546222): remove once this is always "owned".
-  const WebStateOwnership web_state_ownership_;
-
   // Wrappers to the WebStates hosted by the WebStateList.
   std::vector<std::unique_ptr<WebStateWrapper>> web_state_wrappers_;
 
   // An object that determines where new WebState should be inserted and where
   // selection should move when a WebState is detached.
   std::unique_ptr<WebStateListOrderController> order_controller_;
 
   // List of observers notified of changes to the model.
   base::ObserverList<WebStateListObserver, true> observers_;
 
   // Index of the currently active WebState, kInvalidIndex if no such WebState.
   int active_index_ = kInvalidIndex;
 
   DISALLOW_COPY_AND_ASSIGN(WebStateList);
 };
 
 #endif  // IOS_SHARED_CHROME_BROWSER_TABS_WEB_STATE_LIST_H_