Remove windowName from CRWSessionController.

ios/chrome/browser/tabs/tab_model.mm

 // Copyright 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.
 
 #import "ios/chrome/browser/tabs/tab_model.h"
 
 #include <cstdint>
 #include <utility>
 #include <vector>
 
@@ skipping 176 matching lines @@
   // Used to ensure thread-safety of the certificate policy management code.
   base::CancelableTaskTracker _clearPoliciesTaskTracker;
 }
 
 // Session window for the contents of the tab model.
 @property(nonatomic, readonly) SessionWindowIOS* windowForSavingSession;
 
 // Returns YES if tab URL host indicates that tab is an NTP tab.
 - (BOOL)isNTPTab:(Tab*)tab;
 
-// Opens a tab at the specified URL and registers its JS-supplied window name if
-// appropriate. For certain transition types, will consult the order controller
-// and thus may only use |index| as a hint. |parentTab| may be nil if there
-// is no parent associated with this new tab, as may |windowName| if not
-// applicable. |openedByDOM| is YES if the page was opened by DOM.
-// The |index| parameter can be set to
-// TabModelConstants::kTabPositionAutomatically if the caller doesn't have a
-// preference for the position of the tab.
-- (Tab*)insertTabWithLoadParams:
-            (const web::NavigationManager::WebLoadParams&)params
-                     windowName:(NSString*)windowName
-                         opener:(Tab*)parentTab
-                    openedByDOM:(BOOL)openedByDOM
-                        atIndex:(NSUInteger)index
-                   inBackground:(BOOL)inBackground;
-
 // Call to switch the selected tab. Broadcasts about the change in selection.
 // It's ok for |newTab| to be nil in case the last tab is going away. In that
 // case, the "tab deselected" notification gets sent, but no corresponding
 // "tab selected" notification is sent. |persist| indicates whether or not
 // the tab's state should be persisted in history upon switching.
 - (void)changeSelectedTabFrom:(Tab*)oldTab
                            to:(Tab*)newTab
                  persistState:(BOOL)persist;
 
 // Tells the snapshot cache the adjacent tab session ids.
@@ skipping 195 matching lines @@
 
 - (NSUInteger)indexOfTab:(Tab*)tab {
   int index = _webStateList.GetIndexOfWebState(tab.webState);
   if (index == WebStateList::kInvalidIndex)
     return NSNotFound;
 
   DCHECK_GE(index, 0);
   return static_cast<NSUInteger>(index);
 }
 
-- (Tab*)tabWithWindowName:(NSString*)windowName {
-  if (!windowName)
-    return nil;
-  for (Tab* tab in self) {
-    if ([windowName isEqualToString:tab.windowName]) {
-      return tab;
-    }
-  }
-  return nil;
-}
-
 - (Tab*)nextTabWithOpener:(Tab*)tab afterTab:(Tab*)afterTab {
   int startIndex = WebStateList::kInvalidIndex;
   if (afterTab)
     startIndex = _webStateList.GetIndexOfWebState(afterTab.webState);
 
   if (startIndex == WebStateList::kInvalidIndex)
     startIndex = _webStateList.GetIndexOfWebState(tab.webState);
 
   const int index = _webStateList.GetIndexOfNextWebStateOpenedBy(
       tab.webState, startIndex, false);
@@ skipping 20 matching lines @@
 
 - (Tab*)openerOfTab:(Tab*)tab {
   int index = _webStateList.GetIndexOfWebState(tab.webState);
   if (index == WebStateList::kInvalidIndex)
     return nil;
 
   web::WebState* opener = _webStateList.GetOpenerOfWebStateAt(index);
   return opener ? LegacyTabHelper::GetTabForWebState(opener) : nil;
 }
 
-- (Tab*)insertOrUpdateTabWithURL:(const GURL&)URL
-                        referrer:(const web::Referrer&)referrer
-                      transition:(ui::PageTransition)transition
-                      windowName:(NSString*)windowName
-                          opener:(Tab*)parentTab
-                     openedByDOM:(BOOL)openedByDOM
-                         atIndex:(NSUInteger)index
-                    inBackground:(BOOL)inBackground {
+- (Tab*)insertTabWithURL:(const GURL&)URL
+                referrer:(const web::Referrer&)referrer
+              transition:(ui::PageTransition)transition
+                  opener:(Tab*)parentTab
+             openedByDOM:(BOOL)openedByDOM
+                 atIndex:(NSUInteger)index
+            inBackground:(BOOL)inBackground {
   web::NavigationManager::WebLoadParams params(URL);
   params.referrer = referrer;
   params.transition_type = transition;
-  return [self insertOrUpdateTabWithLoadParams:params
-                                    windowName:windowName
-                                        opener:parentTab
-                                   openedByDOM:openedByDOM
-                                       atIndex:index
-                                  inBackground:inBackground];
+  return [self insertTabWithLoadParams:params
+                                opener:parentTab
+                           openedByDOM:openedByDOM
+                               atIndex:index
+                          inBackground:inBackground];
 }
 
-- (Tab*)insertOrUpdateTabWithLoadParams:
-            (const web::NavigationManager::WebLoadParams&)loadParams
-                             windowName:(NSString*)windowName
-                                 opener:(Tab*)parentTab
-                            openedByDOM:(BOOL)openedByDOM
-                                atIndex:(NSUInteger)index
-                           inBackground:(BOOL)inBackground {
-  // Find the tab for the given window name. If found, load with
-  // |originalParams| in it, otherwise create a new tab for it.
-  Tab* tab = [self tabWithWindowName:windowName];
-  if (tab) {
-    // Updating a tab shouldn't be possible with web usage suspended, since
-    // whatever page would be driving it should also be suspended.
-    DCHECK(webUsageEnabled_);
+- (Tab*)insertTabWithLoadParams:
+            (const web::NavigationManager::WebLoadParams&)params
+                         opener:(Tab*)parentTab
+                    openedByDOM:(BOOL)openedByDOM
+                        atIndex:(NSUInteger)index
+                   inBackground:(BOOL)inBackground {
+  DCHECK(_browserState);
+  base::scoped_nsobject<Tab> tab([[Tab alloc] initWithBrowserState:_browserState
+                                                            opener:parentTab
+                                                       openedByDOM:openedByDOM
+                                                             model:self]);
+  [tab webController].webUsageEnabled = webUsageEnabled_;
 
-    web::NavigationManager::WebLoadParams updatedParams(loadParams);
-    updatedParams.is_renderer_initiated = (parentTab != nil);
-    [tab.webController loadWithParams:updatedParams];
+  [self insertTab:tab
+          atIndex:index
+           opener:parentTab
+       transition:params.transition_type];
 
-    // Force the page to start loading even if it's in the background.
-    [tab.webController triggerPendingLoad];
+  if (!inBackground && _tabUsageRecorder)
+    _tabUsageRecorder->TabCreatedForSelection(tab);
 
-    if (!inBackground)
-      [self setCurrentTab:tab];
-  } else {
-    tab = [self insertTabWithLoadParams:loadParams
-                             windowName:windowName
-                                 opener:parentTab
-                            openedByDOM:openedByDOM
-                                atIndex:index
-                           inBackground:inBackground];
-  }
+  [[tab webController] loadWithParams:params];
+  // Force the page to start loading even if it's in the background.
+  if (webUsageEnabled_)
+    [[tab webController] triggerPendingLoad];
+  NSDictionary* userInfo = @{
+    kTabModelTabKey : tab,
+    kTabModelOpenInBackgroundKey : @(inBackground),
+  };
+  [[NSNotificationCenter defaultCenter]
+      postNotificationName:kTabModelNewTabWillOpenNotification
+                    object:self
+                  userInfo:userInfo];
+
+  if (!inBackground)
+    [self setCurrentTab:tab];
 
   return tab;
 }
 
 - (Tab*)insertBlankTabWithTransition:(ui::PageTransition)transition
                               opener:(Tab*)parentTab
                          openedByDOM:(BOOL)openedByDOM
                              atIndex:(NSUInteger)index
                         inBackground:(BOOL)inBackground {
   GURL emptyURL;
   web::NavigationManager::WebLoadParams params(emptyURL);
   params.transition_type = transition;
   // Tabs open by DOM are always renderer initiated.
   params.is_renderer_initiated = openedByDOM;
   return [self insertTabWithLoadParams:params
-                            windowName:nil
                                 opener:parentTab
                            openedByDOM:openedByDOM
                                atIndex:index
                           inBackground:inBackground];
 }
 
 - (Tab*)insertTabWithWebState:(std::unique_ptr<web::WebState>)webState
                       atIndex:(NSUInteger)index {
   DCHECK(_browserState);
   DCHECK_EQ(webState->GetBrowserState(), _browserState);
@@ skipping 314 matching lines @@
   }
   window.selectedIndex = [self indexOfTab:_currentTab];
   return window;
 }
 
 - (BOOL)isNTPTab:(Tab*)tab {
   std::string host = tab.url.host();
   return host == kChromeUINewTabHost || host == kChromeUIBookmarksHost;
 }
 
-- (Tab*)insertTabWithLoadParams:
-            (const web::NavigationManager::WebLoadParams&)params
-                     windowName:(NSString*)windowName
-                         opener:(Tab*)parentTab
-                    openedByDOM:(BOOL)openedByDOM
-                        atIndex:(NSUInteger)index
-                   inBackground:(BOOL)inBackground {
-  DCHECK(_browserState);
-  base::scoped_nsobject<Tab> tab([[Tab alloc]
-      initWithWindowName:windowName
-                  opener:parentTab
-             openedByDOM:openedByDOM
-                   model:self
-            browserState:_browserState]);
-  [tab webController].webUsageEnabled = webUsageEnabled_;
-
-  [self insertTab:tab
-          atIndex:index
-           opener:parentTab
-       transition:params.transition_type];
-
-  if (!inBackground && _tabUsageRecorder)
-    _tabUsageRecorder->TabCreatedForSelection(tab);
-
-  [[tab webController] loadWithParams:params];
-  // Force the page to start loading even if it's in the background.
-  if (webUsageEnabled_)
-    [[tab webController] triggerPendingLoad];
-  NSDictionary* userInfo = @{
-    kTabModelTabKey : tab,
-    kTabModelOpenInBackgroundKey : @(inBackground),
-  };
-  [[NSNotificationCenter defaultCenter]
-      postNotificationName:kTabModelNewTabWillOpenNotification
-                    object:self
-                  userInfo:userInfo];
-
-  if (!inBackground)
-    [self setCurrentTab:tab];
-
-  return tab;
-}
-
 - (void)changeSelectedTabFrom:(Tab*)oldTab
                            to:(Tab*)newTab
                  persistState:(BOOL)persist {
   if (oldTab) {
     // Save state, such as scroll position, before switching tabs.
     if (oldTab != newTab && persist)
       [oldTab recordStateInHistory];
     [self postNotificationName:kTabModelTabDeselectedNotification
                        withTab:oldTab];
   }
@@ skipping 170 matching lines @@
 - (void)applicationWillEnterForeground:(NSNotification*)notify {
   if (_tabUsageRecorder) {
     _tabUsageRecorder->AppWillEnterForeground();
   }
 }
 
 @end
 
 @implementation TabModel (PrivateForTestingOnly)
 
-- (Tab*)addTabWithURL:(const GURL&)URL
-             referrer:(const web::Referrer&)referrer
-           windowName:(NSString*)windowName {
+- (Tab*)addTabWithURL:(const GURL&)URL referrer:(const web::Referrer&)referrer {
   return [self insertTabWithURL:URL
                        referrer:referrer
-                     windowName:windowName
                          opener:nil
                         atIndex:self.count];
 }
 
 - (Tab*)insertTabWithURL:(const GURL&)URL
                 referrer:(const web::Referrer&)referrer
-              windowName:(NSString*)windowName
                   opener:(Tab*)parentTab
                  atIndex:(NSUInteger)index {
   DCHECK(_browserState);
-  base::scoped_nsobject<Tab> tab([[Tab alloc]
-      initWithWindowName:windowName
-                  opener:parentTab
-             openedByDOM:NO
-                   model:self
-            browserState:_browserState]);
+  base::scoped_nsobject<Tab> tab([[Tab alloc] initWithBrowserState:_browserState
+                                                            opener:parentTab
+                                                       openedByDOM:NO
+                                                             model:self]);
   web::NavigationManager::WebLoadParams params(URL);
   params.referrer = referrer;
   params.transition_type = ui::PAGE_TRANSITION_TYPED;
   [[tab webController] loadWithParams:params];
   [tab webController].webUsageEnabled = webUsageEnabled_;
   [self insertTab:tab atIndex:index opener:parentTab];
   return tab;
 }
 
 @end