[ios] Moves tab_switcher code out of the ios_internal namespace.

ios/chrome/browser/ui/tab_switcher/tab_switcher_controller.mm

 // Copyright 2015 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/ui/tab_switcher/tab_switcher_controller.h"
 
 #include "base/ios/block_types.h"
 #include "base/ios/weak_nsobject.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/metrics/user_metrics.h"
@@ skipping 118 matching lines @@
 // not be nil.
 - (void)performTabSwitcherTransition:(TransitionType)transitionType
                            withModel:(TabModel*)tabModel
                             animated:(BOOL)animated
                       withCompletion:(ProceduralBlock)completion;
 
 // Returns the index of the currently selected panel.
 - (NSInteger)currentPanelIndex;
 
 // Returns the session type of the panel and the given index.
-- (ios_internal::SessionType)sessionTypeForPanelIndex:(NSInteger)panelIndex;
+- (SessionType)sessionTypeForPanelIndex:(NSInteger)panelIndex;
 
 // Returns the tab model corresponding to the given session type.
 // There is no tab model for distant sessions so it returns nil for distant
 // sessions type.
-- (TabModel*)tabModelForSessionType:(ios_internal::SessionType)sessionType;
+- (TabModel*)tabModelForSessionType:(SessionType)sessionType;
 
 // Returns the tab model of the currently selected tab.
 - (TabModel*)currentSelectedModel;
 
 // Calls tabSwitcherDismissWithModel:animated: with the |animated| parameter
 // set to YES.
 - (void)tabSwitcherDismissWithModel:(TabModel*)model;
 
 // Dismisses the tab switcher using the given tab model. The completion block is
 // called at the end of the animation. The tab switcher delegate method
@@ skipping 45 matching lines @@
     _tabSwitcherModel.reset([[TabSwitcherModel alloc]
         initWithBrowserState:browserState
                     delegate:self
                 mainTabModel:mainTabModel
                  otrTabModel:otrTabModel
                    withCache:_cache]);
     _controllersOfDistantSessions.reset([[NSMutableArray alloc] init]);
     [self loadTabSwitcherView];
     _onTheRecordSession.reset([[TabSwitcherPanelController alloc]
                 initWithModel:_tabSwitcherModel
-        forLocalSessionOfType:ios_internal::SessionType::REGULAR_SESSION
+        forLocalSessionOfType:SessionType::REGULAR_SESSION
                     withCache:_cache
                  browserState:_browserState]);
     [_onTheRecordSession setDelegate:self];
     _offTheRecordSession.reset([[TabSwitcherPanelController alloc]
                 initWithModel:_tabSwitcherModel
-        forLocalSessionOfType:ios_internal::SessionType::OFF_THE_RECORD_SESSION
+        forLocalSessionOfType:SessionType::OFF_THE_RECORD_SESSION
                     withCache:_cache
                  browserState:_browserState]);
     [_offTheRecordSession setDelegate:self];
     [_tabSwitcherView addPanelView:[_offTheRecordSession view]
                            atIndex:kLocalTabsOffTheRecordPanelIndex];
     [_tabSwitcherView addPanelView:[_onTheRecordSession view]
                            atIndex:kLocalTabsOnTheRecordPanelIndex];
     [self addPromoPanelForSignInPanelType:[_tabSwitcherModel signInPanelType]];
     [[_tabSwitcherView headerView] reloadData];
     [_tabSwitcherModel syncedSessionsChanged];
@@ skipping 158 matching lines @@
 
   switch (command) {
     case IDC_NEW_INCOGNITO_TAB:  // fallthrough
     case IDC_NEW_TAB: {
       // Ensure that the right mode is showing.
       NSInteger panelIndex = (command == IDC_NEW_TAB)
                                  ? kLocalTabsOnTheRecordPanelIndex
                                  : kLocalTabsOffTheRecordPanelIndex;
       [_tabSwitcherView selectPanelAtIndex:panelIndex];
 
-      const ios_internal::SessionType panelSessionType =
-          (command == IDC_NEW_TAB)
-              ? ios_internal::SessionType::REGULAR_SESSION
-              : ios_internal::SessionType::OFF_THE_RECORD_SESSION;
+      const SessionType panelSessionType =
+          (command == IDC_NEW_TAB) ? SessionType::REGULAR_SESSION
+                                   : SessionType::OFF_THE_RECORD_SESSION;
 
       TabModel* model = [self tabModelForSessionType:panelSessionType];
       [self dismissWithNewTabAnimation:GURL(kChromeUINewTabURL)
                                atIndex:NSNotFound
                             transition:ui::PAGE_TRANSITION_TYPED
                               tabModel:model];
     } break;
     case IDC_TOGGLE_TAB_SWITCHER:
       [self tabSwitcherDismissWithCurrentSelectedModel];
       break;
@@ skipping 321 matching lines @@
   return [_tabSwitcherView currentPanelIndex];
 }
 
 - (int)offsetToDistantSessionPanels {
   if (_signInPanelType == TabSwitcherSignInPanelsType::NO_PANEL) {
     return kSignInPromoPanelIndex;
   }
   return kSignInPromoPanelIndex + 1;
 }
 
-- (ios_internal::SessionType)sessionTypeForPanelIndex:(NSInteger)panelIndex {
+- (SessionType)sessionTypeForPanelIndex:(NSInteger)panelIndex {
   if (panelIndex == kLocalTabsOffTheRecordPanelIndex)
-    return ios_internal::SessionType::OFF_THE_RECORD_SESSION;
+    return SessionType::OFF_THE_RECORD_SESSION;
   if (panelIndex == kLocalTabsOnTheRecordPanelIndex)
-    return ios_internal::SessionType::REGULAR_SESSION;
-  return ios_internal::SessionType::DISTANT_SESSION;
+    return SessionType::REGULAR_SESSION;
+  return SessionType::DISTANT_SESSION;
 }
 
-- (TabModel*)tabModelForSessionType:(ios_internal::SessionType)sessionType {
+- (TabModel*)tabModelForSessionType:(SessionType)sessionType {
   switch (sessionType) {
-    case ios_internal::SessionType::REGULAR_SESSION:
+    case SessionType::REGULAR_SESSION:
       return [_tabSwitcherModel mainTabModel];
       break;
-    case ios_internal::SessionType::OFF_THE_RECORD_SESSION:
+    case SessionType::OFF_THE_RECORD_SESSION:
       return [_tabSwitcherModel otrTabModel];
       break;
-    case ios_internal::SessionType::DISTANT_SESSION:
+    case SessionType::DISTANT_SESSION:
       return nil;
       break;
   }
 }
 
 - (TabModel*)currentSelectedModel {
   const NSInteger currentPanelIndex = [self currentPanelIndex];
-  const ios_internal::SessionType sessionType =
+  const SessionType sessionType =
       [self sessionTypeForPanelIndex:currentPanelIndex];
   TabModel* model = [self tabModelForSessionType:sessionType];
   if (!model)
     model = _onLoadActiveModel;
   return model;
 }
 
 - (void)selectPanelForTabModel:(TabModel*)selectedTabModel {
   DCHECK(selectedTabModel == [_tabSwitcherModel otrTabModel] ||
          selectedTabModel == [_tabSwitcherModel mainTabModel]);
@@ skipping 221 matching lines @@
   for (TabSwitcherPanelController* panel in _controllersOfDistantSessions
            .get()) {
     DCHECK([panel isKindOfClass:[TabSwitcherPanelController class]]);
     if ([panel sessionTag] == tag) {
       [panel updateCollectionViewIfNeeded];
       return;
     }
   }
 }
 
-- (void)localSessionMayNeedUpdate:(ios_internal::SessionType)type {
-  if (type == ios_internal::SessionType::REGULAR_SESSION) {
+- (void)localSessionMayNeedUpdate:(SessionType)type {
+  if (type == SessionType::REGULAR_SESSION) {

[sdefresne, 2017/01/03 16:04:30]

nit: it would be better to use a switch statement here I think (like in
-sizeForItemAtIndex:inSession: for example).

[rohitrao (ping after 24h), 2017/01/04 13:36:37]

Acknowledged.

     [_onTheRecordSession updateCollectionViewIfNeeded];
   } else {
-    DCHECK(type == ios_internal::SessionType::OFF_THE_RECORD_SESSION);
+    DCHECK(type == SessionType::OFF_THE_RECORD_SESSION);
     [_offTheRecordSession updateCollectionViewIfNeeded];
   }
 }
 
 - (void)signInPanelChangedTo:(TabSwitcherSignInPanelsType)newPanelType {
   if (_signInPanelType == newPanelType)
     return;
 
   // Remove promo panel that is no longer relevant, if any.
   if (_signInPanelType != TabSwitcherSignInPanelsType::NO_PANEL) {
@@ skipping 13 matching lines @@
   if (panelType != TabSwitcherSignInPanelsType::NO_PANEL) {
     TabSwitcherPanelOverlayView* panelView =
         [[[TabSwitcherPanelOverlayView alloc] initWithFrame:CGRectZero
                                                browserState:_browserState]
             autorelease];
     [panelView setOverlayType:PanelOverlayTypeFromSignInPanelsType(panelType)];
     [_tabSwitcherView addPanelView:panelView atIndex:kSignInPromoPanelIndex];
   }
 }
 
-- (CGSize)sizeForItemAtIndex:(NSUInteger)index
-                   inSession:(ios_internal::SessionType)session {
+- (CGSize)sizeForItemAtIndex:(NSUInteger)index inSession:(SessionType)session {
   switch (session) {
-    case ios_internal::SessionType::OFF_THE_RECORD_SESSION:
+    case SessionType::OFF_THE_RECORD_SESSION:
       return [[_offTheRecordSession view] cellSize];
-    case ios_internal::SessionType::REGULAR_SESSION:
+    case SessionType::REGULAR_SESSION:
       return [[_onTheRecordSession view] cellSize];
-    case ios_internal::SessionType::DISTANT_SESSION:
+    case SessionType::DISTANT_SESSION:
       NOTREACHED();
       return {};
   }
 }
 
 #pragma mark - TabSwitcherHeaderViewDelegate
 
 - (void)tabSwitcherHeaderViewDismiss:(TabSwitcherHeaderView*)view {
   [self tabSwitcherDismissWithCurrentSelectedModel];
 }
@@ skipping 41 matching lines @@
       NSString* cellTitle = nil;
 
       if (index < _controllersOfDistantSessions.get().count) {
         TabSwitcherPanelController* panel =
             [_controllersOfDistantSessions objectAtIndex:index];
         const synced_sessions::DistantSession* distantSession =
             [panel distantSession];
         deviceType = distantSession->device_type;
         cellTitle = base::SysUTF8ToNSString(distantSession->name);
       }
-      ios_internal::SessionCellType cellType;
+      SessionCellType cellType;
       switch (deviceType) {
         case sync_sessions::SyncedSession::TYPE_PHONE:
-          cellType = ios_internal::kPhoneRemoteSessionCell;
+          cellType = kPhoneRemoteSessionCell;
           break;
         case sync_sessions::SyncedSession::TYPE_TABLET:
-          cellType = ios_internal::kTabletRemoteSessionCell;
+          cellType = kTabletRemoteSessionCell;
           break;
         default:
-          cellType = ios_internal::kLaptopRemoteSessionCell;
+          cellType = kLaptopRemoteSessionCell;
           break;
       }
       SessionCellData* sessionData = [[[SessionCellData alloc]
           initWithSessionCellType:cellType] autorelease];
       sessionData.title = cellTitle;
       return sessionData;
     }
   }
 }
 
@@ skipping 67 matching lines @@
   DCHECK(tab);
   [self openTabWithContentOfDistantTab:tab];
   base::RecordAction(
       base::UserMetricsAction("MobileTabSwitcherOpenDistantTab"));
 }
 
 - (void)tabSwitcherPanelController:
             (TabSwitcherPanelController*)tabSwitcherPanelController
                  didSelectLocalTab:(Tab*)tab {
   DCHECK(tab);
-  const ios_internal::SessionType panelSessionType =
-      tabSwitcherPanelController.sessionType;
+  const SessionType panelSessionType = tabSwitcherPanelController.sessionType;
   TabModel* tabModel = [self tabModelForSessionType:panelSessionType];
   [tabModel setCurrentTab:tab];
   [self.delegate tabSwitcher:self
       dismissTransitionWillStartWithActiveModel:tabModel];
   [self tabSwitcherDismissWithModel:tabModel];
-  if (panelSessionType == ios_internal::SessionType::OFF_THE_RECORD_SESSION) {
+  if (panelSessionType == SessionType::OFF_THE_RECORD_SESSION) {
     base::RecordAction(
         base::UserMetricsAction("MobileTabSwitcherOpenIncognitoTab"));
   } else {
     base::RecordAction(
         base::UserMetricsAction("MobileTabSwitcherOpenNonIncognitoTab"));
   }
 }
 
 - (void)tabSwitcherPanelController:
             (TabSwitcherPanelController*)tabSwitcherPanelController
                   didCloseLocalTab:(Tab*)tab {
   DCHECK(tab);
-  const ios_internal::SessionType panelSessionType =
-      tabSwitcherPanelController.sessionType;
+  const SessionType panelSessionType = tabSwitcherPanelController.sessionType;
   [tab close];
-  if (panelSessionType == ios_internal::SessionType::OFF_THE_RECORD_SESSION) {
+  if (panelSessionType == SessionType::OFF_THE_RECORD_SESSION) {
     base::RecordAction(
         base::UserMetricsAction("MobileTabSwitcherCloseIncognitoTab"));
   } else {
     base::RecordAction(
         base::UserMetricsAction("MobileTabSwitcherCloseNonIncognitoTab"));
   }
 }
 
 - (void)tabSwitcherPanelControllerDidUpdateOverlayViewVisibility:
     (TabSwitcherPanelController*)tabSwitcherPanelController {
   [_tabSwitcherView updateOverlayButtonState];
 }
 
 @end