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

ios/chrome/browser/ui/tab_switcher/tab_switcher_model.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_model.h"
 
 #include <memory>
 
 #include "base/memory/ptr_util.h"
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/sessions/core/session_id.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #include "ios/chrome/browser/signin/signin_manager_factory.h"
 #include "ios/chrome/browser/sync/ios_chrome_profile_sync_service_factory.h"
 #include "ios/chrome/browser/sync/sync_setup_service.h"
 #include "ios/chrome/browser/sync/sync_setup_service_factory.h"
 #import "ios/chrome/browser/tabs/tab.h"
 #import "ios/chrome/browser/tabs/tab_model.h"
 #include "ios/chrome/browser/ui/ntp/recent_tabs/synced_sessions.h"
 #import "ios/chrome/browser/ui/tab_switcher/session_changes.h"
 #import "ios/chrome/browser/ui/tab_switcher/tab_model_snapshot.h"
 #import "ios/chrome/browser/ui/tab_switcher/tab_switcher_cache.h"
 #import "ios/chrome/browser/ui/tab_switcher/tab_switcher_model_private.h"
 #import "ios/chrome/browser/ui/tab_switcher/tab_switcher_panel_cell.h"
 
-namespace ios_internal {
-
-bool IsLocalSession(SessionType sessionType) {
+bool SessionTypeIsLocalSession(SessionType sessionType) {
   return sessionType == SessionType::OFF_THE_RECORD_SESSION ||
          sessionType == SessionType::REGULAR_SESSION;
 }
 
-}  // namespace ios_internal
-
 namespace {
 
 class TagAndIndex {
  public:
   TagAndIndex(std::string const& tag, size_t index)
       : tag_(tag), index_(index) {}
   std::string tag_;
   size_t index_;
   bool operator<(const TagAndIndex& other) const { return tag_ < other.tag_; }
 };
@@ skipping 24 matching lines @@
       _syncedSessionsObserver;
   // Snapshots of the |_mainTabModel| and |_otrTabModel|.
   std::unique_ptr<TabModelSnapshot> _mainTabModelSnapshot;
   std::unique_ptr<TabModelSnapshot> _otrTabModelSnapshot;
   // The cache holding resized tabs snapshots.
   base::scoped_nsobject<TabSwitcherCache> _cache;
 }
 
 // Returns the type of the local session corresponding to the given |tabModel|.
 // |tabModel| MUST be equal to either |_mainTabModel|, or |_otrTabModel|.
-- (ios_internal::SessionType)typeOfLocalSessionForTabModel:(TabModel*)tabModel;
+- (SessionType)typeOfLocalSessionForTabModel:(TabModel*)tabModel;
 @end
 
 @implementation TabSwitcherModel
 
 @synthesize mainTabModel = _mainTabModel;
 @synthesize otrTabModel = _otrTabModel;
 
 - (instancetype)initWithBrowserState:(ios::ChromeBrowserState*)browserState
                             delegate:(id<TabSwitcherModelDelegate>)delegate
                         mainTabModel:(TabModel*)mainTabModel
@@ skipping 55 matching lines @@
 }
 
 - (NSInteger)distantSessionCount {
   return _syncedSessions->GetSessionCount();
 }
 
 - (ios::ChromeBrowserState*)browserState {
   return _browserState;
 }
 
-- (TabModel*)tabModelForSessionOfType:(ios_internal::SessionType)type {
-  DCHECK(type == ios_internal::SessionType::OFF_THE_RECORD_SESSION ||
-         type == ios_internal::SessionType::REGULAR_SESSION);
-  return type == ios_internal::SessionType::OFF_THE_RECORD_SESSION
-             ? _otrTabModel
-             : _mainTabModel;
+- (TabModel*)tabModelForSessionOfType:(SessionType)type {
+  DCHECK(type == SessionType::OFF_THE_RECORD_SESSION ||

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

nit: this could be rewritten like this

  DCHECK(SessionTypeIsLocalSession(type));

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

Acknowledged.

+         type == SessionType::REGULAR_SESSION);
+  return type == SessionType::OFF_THE_RECORD_SESSION ? _otrTabModel
+                                                     : _mainTabModel;
 }
 
-- (NSInteger)numberOfTabsInLocalSessionOfType:(ios_internal::SessionType)type {
+- (NSInteger)numberOfTabsInLocalSessionOfType:(SessionType)type {
   TabModelSnapshot* tabModelSnapshot = [self tabModelSnapshotForSession:type];
   return tabModelSnapshot->tabs().size();
 }
 
-- (Tab*)tabAtIndex:(NSUInteger)index
-    inLocalSessionOfType:(ios_internal::SessionType)type {
+- (Tab*)tabAtIndex:(NSUInteger)index inLocalSessionOfType:(SessionType)type {
   TabModelSnapshot* tabModelSnapshot = [self tabModelSnapshotForSession:type];
   return tabModelSnapshot->tabs()[index];
 }
 
 - (std::unique_ptr<TabModelSnapshot>)tabModelSnapshotForLocalSession:
-    (ios_internal::SessionType)type {
+    (SessionType)type {
   TabModel* tm = nullptr;
   switch (type) {
-    case ios_internal::SessionType::OFF_THE_RECORD_SESSION:
+    case SessionType::OFF_THE_RECORD_SESSION:
       tm = _otrTabModel;
       break;
-    case ios_internal::SessionType::REGULAR_SESSION:
+    case SessionType::REGULAR_SESSION:
       tm = _mainTabModel;
       break;
     default:
       NOTREACHED();
       break;
   }
   return base::MakeUnique<TabModelSnapshot>(tm);
 }
 
 - (std::unique_ptr<const synced_sessions::DistantSession>)distantSessionForTag:
@@ skipping 116 matching lines @@
   std::set<TagAndIndex> tagsOfOtherSessions;
   std::set_intersection(
       tagsOfNewSessions.begin(), tagsOfNewSessions.end(),
       tagsOfOldSessions.begin(), tagsOfOldSessions.end(),
       std::inserter(tagsOfOtherSessions, tagsOfOtherSessions.end()));
   for (TagAndIndex const& tagAndIndexOfSession : tagsOfOtherSessions) {
     [delegate distantSessionMayNeedUpdate:tagAndIndexOfSession.tag_];
   }
 }
 
-- (ios_internal::SessionType)typeOfLocalSessionForTabModel:(TabModel*)tabModel {
+- (SessionType)typeOfLocalSessionForTabModel:(TabModel*)tabModel {
   DCHECK(tabModel == _mainTabModel || tabModel == _otrTabModel);
   if (tabModel == _otrTabModel)
-    return ios_internal::SessionType::OFF_THE_RECORD_SESSION;
-  return ios_internal::SessionType::REGULAR_SESSION;
+    return SessionType::OFF_THE_RECORD_SESSION;
+  return SessionType::REGULAR_SESSION;
 }
 
-- (TabModelSnapshot*)tabModelSnapshotForSession:
-    (ios_internal::SessionType)type {
+- (TabModelSnapshot*)tabModelSnapshotForSession:(SessionType)type {
   switch (type) {
-    case ios_internal::SessionType::OFF_THE_RECORD_SESSION:
+    case SessionType::OFF_THE_RECORD_SESSION:
       return _otrTabModelSnapshot.get();
-    case ios_internal::SessionType::REGULAR_SESSION:
+    case SessionType::REGULAR_SESSION:
       return _mainTabModelSnapshot.get();
     default:
       NOTREACHED();
       return nullptr;
       break;
   }
 }
 
 - (void)setTabModelSnapshot:(std::unique_ptr<TabModelSnapshot>)tabModelSnapshot
-                 forSession:(ios_internal::SessionType)type {
+                 forSession:(SessionType)type {
   switch (type) {
-    case ios_internal::SessionType::OFF_THE_RECORD_SESSION:
+    case SessionType::OFF_THE_RECORD_SESSION:
       _otrTabModelSnapshot = std::move(tabModelSnapshot);
       break;
-    case ios_internal::SessionType::REGULAR_SESSION:
+    case SessionType::REGULAR_SESSION:
       _mainTabModelSnapshot = std::move(tabModelSnapshot);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 - (void)tabModelChanged:(TabModel*)tabModel {
-  ios_internal::SessionType sessionType =
-      [self typeOfLocalSessionForTabModel:tabModel];
+  SessionType sessionType = [self typeOfLocalSessionForTabModel:tabModel];
   [_delegate localSessionMayNeedUpdate:sessionType];
 }
 
 #pragma mark - SyncedSessionsObserver
 
 - (void)reloadSessions {
   [self syncedSessionsChanged];
 }
 
 - (void)onSyncStateChanged {
@@ skipping 33 matching lines @@
   [self tabModelChanged:model];
 }
 
 - (void)tabModel:(TabModel*)model
     didChangeTabSnapshot:(Tab*)tab
                withImage:(UIImage*)image {
   [self tabModelChanged:model];
 }
 
 @end