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

ios/chrome/browser/ui/tab_switcher/tab_switcher_panel_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_panel_controller.h"
 
 #include "base/logging.h"
 #import "base/mac/scoped_nsobject.h"
 #include "base/strings/sys_string_conversions.h"
 #import "ios/chrome/browser/tabs/tab.h"
@@ skipping 17 matching lines @@
 }
 
 }  // namespace
 
 @interface TabSwitcherPanelController ()<UICollectionViewDataSource,
                                          SessionCellDelegate> {
   ios::ChromeBrowserState* _browserState;  // Weak.
   base::scoped_nsobject<TabSwitcherPanelView> _panelView;
   base::scoped_nsobject<TabSwitcherModel> _model;
   std::string _sessionTag;
-  ios_internal::SessionType _sessionType;
+  TabSwitcherSessionType _sessionType;
   base::scoped_nsobject<TabSwitcherCache> _cache;
   base::scoped_nsobject<TabSwitcherPanelOverlayView> _overlayView;
   std::unique_ptr<const synced_sessions::DistantSession> _distantSession;
   std::unique_ptr<const TabModelSnapshot> _localSession;
 }
 
 // Changes the visibility of the zero tab state overlay view.
 - (void)setZeroTabStateOverlayVisible:(BOOL)show;
 
 @end
 
 @implementation TabSwitcherPanelController
 
 @synthesize delegate = _delegate;
 @synthesize sessionType = _sessionType;
 
 - (instancetype)initWithModel:(TabSwitcherModel*)model
      forDistantSessionWithTag:(std::string const&)sessionTag
                  browserState:(ios::ChromeBrowserState*)browserState {
   self = [super init];
   if (self) {
     DCHECK(model);
-    _sessionType = ios_internal::SessionType::DISTANT_SESSION;
+    _sessionType = TabSwitcherSessionType::DISTANT_SESSION;
     _model.reset([model retain]);
     _distantSession = [model distantSessionForTag:sessionTag];
     _sessionTag = sessionTag;
     _browserState = browserState;
     [self loadView];
   }
   return self;
 }
 
 - (instancetype)initWithModel:(TabSwitcherModel*)model
-        forLocalSessionOfType:(ios_internal::SessionType)sessionType
+        forLocalSessionOfType:(TabSwitcherSessionType)sessionType
                     withCache:(TabSwitcherCache*)cache
                  browserState:(ios::ChromeBrowserState*)browserState {
   self = [super init];
   if (self) {
     DCHECK(model);
     _sessionType = sessionType;
     _model.reset([model retain]);
     _localSession = [model tabModelSnapshotForLocalSession:sessionType];
     _cache.reset([cache retain]);
     _browserState = browserState;
     [self loadView];
   }
   return self;
 }
 
 - (TabSwitcherPanelView*)view {
   return _panelView;
 }
 
 - (std::string)sessionTag {
   return _sessionTag;
 }
 
 - (void)setDelegate:(id<TabSwitcherPanelControllerDelegate>)delegate {
   _delegate = delegate;
   [[_panelView collectionView] performBatchUpdates:nil completion:nil];
 }
 
 - (BOOL)shouldShowNewTabButton {
-  if (_sessionType == ios_internal::SessionType::DISTANT_SESSION) {
+  if (_sessionType == TabSwitcherSessionType::DISTANT_SESSION) {
     return NO;
   } else {
     return ![self isOverlayVisible];
   }
 }
 
 - (void)updateCollectionViewIfNeeded {
-  if (_sessionType == ios_internal::SessionType::DISTANT_SESSION) {
+  if (_sessionType == TabSwitcherSessionType::DISTANT_SESSION) {
     UICollectionView* collectionView = [_panelView collectionView];
     // TODO(crbug.com/633928) Compute SessionChanges outside of the
     // updateBlock.
     auto updateBlock = ^{
       std::unique_ptr<const synced_sessions::DistantSession> newDistantSession =
           [_model distantSessionForTag:_sessionTag];
       std::vector<size_t> oldTabsHashes;
       std::vector<size_t> newTabsHashes;
       FillVectorWithHashesUsingDistantSession(*_distantSession.get(),
                                               &oldTabsHashes);
       FillVectorWithHashesUsingDistantSession(*newDistantSession.get(),
                                               &newTabsHashes);
-      ios_internal::SessionChanges changes(oldTabsHashes, newTabsHashes);
+      SessionChanges changes(oldTabsHashes, newTabsHashes);
       if (changes.hasChanges()) {
         _distantSession = std::move(newDistantSession);
         [self applyChanges:changes toCollectionView:collectionView];
       }
     };
     [collectionView performBatchUpdates:updateBlock completion:nil];
   } else {
     UICollectionView* collectionView = [_panelView collectionView];
     auto updateBlock = ^{
       std::unique_ptr<const TabModelSnapshot> newLocalSession =
           [_model tabModelSnapshotForLocalSession:_sessionType];
-      ios_internal::SessionChanges changes(_localSession->hashes(),
-                                           newLocalSession->hashes());
+      SessionChanges changes(_localSession->hashes(),
+                             newLocalSession->hashes());
       if (changes.hasChanges()) {
         _localSession = std::move(newLocalSession);
         [self applyChanges:changes toCollectionView:collectionView];
       }
     };
     [collectionView performBatchUpdates:updateBlock completion:nil];
   }
 }
 
-- (void)applyChanges:(ios_internal::SessionChanges&)changes
+- (void)applyChanges:(SessionChanges&)changes
     toCollectionView:(UICollectionView*)collectionView {
   NSMutableArray* deletedIndexes = [NSMutableArray array];
   NSMutableArray* insertedIndexes = [NSMutableArray array];
   NSMutableArray* updatedIndexes = [NSMutableArray array];
   for (size_t i : changes.deletions()) {
     NSInteger deletedTabIndex = static_cast<NSInteger>(i);
     [deletedIndexes
         addObject:[NSIndexPath indexPathForItem:deletedTabIndex inSection:0]];
   }
   for (size_t i : changes.insertions()) {
@@ skipping 38 matching lines @@
 
 - (UICollectionView*)collectionView {
   return [_panelView collectionView];
 }
 
 #pragma mark - UICollectionViewDataSource
 
 - (NSInteger)collectionView:(UICollectionView*)collectionView
      numberOfItemsInSection:(NSInteger)section {
   DCHECK_EQ(section, 0);
-  if (_sessionType == ios_internal::SessionType::DISTANT_SESSION) {
+  if (_sessionType == TabSwitcherSessionType::DISTANT_SESSION) {
     CHECK(_distantSession);
     return _distantSession->tabs.size();
   } else {
     CHECK(_localSession);
     NSInteger numberOfTabs = _localSession->tabs().size();
     [self setZeroTabStateOverlayVisible:numberOfTabs == 0];
     return numberOfTabs;
   }
 }
 
 - (UICollectionViewCell*)collectionView:(UICollectionView*)collectionView
                  cellForItemAtIndexPath:(NSIndexPath*)indexPath {
   UICollectionViewCell* cell = nil;
   NSUInteger tabIndex = indexPath.item;
-  if (_sessionType == ios_internal::SessionType::DISTANT_SESSION) {
+  if (_sessionType == TabSwitcherSessionType::DISTANT_SESSION) {
     cell = [collectionView
         dequeueReusableCellWithReuseIdentifier:[TabSwitcherDistantSessionCell
                                                    identifier]
                                   forIndexPath:indexPath];
     DCHECK([cell isKindOfClass:[TabSwitcherDistantSessionCell class]]);
     TabSwitcherDistantSessionCell* panelCell =
         static_cast<TabSwitcherDistantSessionCell*>(cell);
     CHECK(_distantSession);
     const std::size_t distantSessionTabCount = _distantSession->tabs.size();
     LOG_ASSERT(tabIndex < distantSessionTabCount)
@@ skipping 24 matching lines @@
 #pragma mark - SessionCellDelegate
 
 - (TabSwitcherCache*)tabSwitcherCache {
   return _cache;
 }
 
 - (void)cellPressed:(UICollectionViewCell*)cell {
   const NSInteger tabIndex =
       [[_panelView collectionView] indexPathForCell:cell].item;
 
-  if (_sessionType == ios_internal::SessionType::DISTANT_SESSION) {
+  if (_sessionType == TabSwitcherSessionType::DISTANT_SESSION) {
     synced_sessions::DistantTab* tab = _distantSession->tabs[tabIndex].get();
     if (tab)
       [self.delegate tabSwitcherPanelController:self didSelectDistantTab:tab];
   } else {
     Tab* tab = _localSession->tabs()[tabIndex];
     if (tab)
       [self.delegate tabSwitcherPanelController:self didSelectLocalTab:tab];
   }
 }
 
 - (void)deleteButtonPressedForCell:(UICollectionViewCell*)cell {
-  DCHECK(_sessionType != ios_internal::SessionType::DISTANT_SESSION);
+  DCHECK(_sessionType != TabSwitcherSessionType::DISTANT_SESSION);
   const NSInteger tabIndex =
       [[_panelView collectionView] indexPathForCell:cell].item;
   Tab* tab = _localSession->tabs()[tabIndex];
   if (tab)
     [self.delegate tabSwitcherPanelController:self didCloseLocalTab:tab];
 }
 
 #pragma mark - Private
 
 - (BOOL)isOverlayVisible {
   return _overlayView && [_overlayView alpha] != 0.0;
 }
 
 - (void)setZeroTabStateOverlayVisible:(BOOL)show {
   if (show == [self isOverlayVisible])
     return;
 
-  DCHECK(ios_internal::IsLocalSession(_sessionType));
+  DCHECK(TabSwitcherSessionTypeIsLocalSession(_sessionType));
 
   if (!_overlayView) {
     _overlayView.reset([[TabSwitcherPanelOverlayView alloc]
         initWithFrame:[_panelView bounds]
          browserState:_browserState]);
     [_overlayView
         setOverlayType:
-            (_sessionType == ios_internal::SessionType::OFF_THE_RECORD_SESSION)
+            (_sessionType == TabSwitcherSessionType::OFF_THE_RECORD_SESSION)
                 ? TabSwitcherPanelOverlayType::
                       OVERLAY_PANEL_USER_NO_INCOGNITO_TABS
                 : TabSwitcherPanelOverlayType::OVERLAY_PANEL_USER_NO_OPEN_TABS];
 
     [_overlayView setAlpha:0];
     [_overlayView setAutoresizingMask:UIViewAutoresizingFlexibleHeight |
                                       UIViewAutoresizingFlexibleWidth];
     [_panelView addSubview:_overlayView];
     [_overlayView setNeedsLayout];
   }
@@ skipping 12 matching lines @@
   _panelView.reset(
       [[TabSwitcherPanelView alloc] initWithSessionType:_sessionType]);
   _panelView.get().collectionView.dataSource = self;
 }
 
 - (synced_sessions::DistantSession const*)distantSession {
   return _distantSession.get();
 }
 
 @end