[Sync] Fix namespaces for the sync_sessions component.

components/sync_sessions/synced_session_tracker_unittest.cc

 // 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.
 
 #include "components/sync_sessions/synced_session_tracker.h"
 
 #include <string>
 #include <vector>
 
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/sessions/core/serialized_navigation_entry_test_helper.h"
 #include "components/sessions/core/session_types.h"
 #include "components/sync_sessions/fake_sync_sessions_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace browser_sync {
+namespace sync_sessions {
 
 namespace {
 
 const char kValidUrl[] = "http://www.example.com";
 const char kInvalidUrl[] = "invalid.url";
 
 }  // namespace
 
 class SyncedSessionTrackerTest : public testing::Test {
  public:
   SyncedSessionTrackerTest() : tracker_(&sessions_client_) {}
   ~SyncedSessionTrackerTest() override {}
 
   SyncedSessionTracker* GetTracker() { return &tracker_; }
 
  private:
-  sync_sessions::FakeSyncSessionsClient sessions_client_;
+  FakeSyncSessionsClient sessions_client_;
   SyncedSessionTracker tracker_;
 };
 
 TEST_F(SyncedSessionTrackerTest, GetSession) {
-  sync_driver::SyncedSession* session1 = GetTracker()->GetSession("tag");
-  sync_driver::SyncedSession* session2 = GetTracker()->GetSession("tag2");
+  SyncedSession* session1 = GetTracker()->GetSession("tag");
+  SyncedSession* session2 = GetTracker()->GetSession("tag2");
   ASSERT_EQ(session1, GetTracker()->GetSession("tag"));
   ASSERT_NE(session1, session2);
   // Should clean up memory on its own.
 }
 
 TEST_F(SyncedSessionTrackerTest, GetTabUnmapped) {
   sessions::SessionTab* tab = GetTracker()->GetTab("tag", 0, 0);
   ASSERT_EQ(tab, GetTracker()->GetTab("tag", 0, 0));
   // Should clean up memory on its own.
 }
 
 TEST_F(SyncedSessionTrackerTest, PutWindowInSession) {
   GetTracker()->PutWindowInSession("tag", 0);
-  sync_driver::SyncedSession* session = GetTracker()->GetSession("tag");
+  SyncedSession* session = GetTracker()->GetSession("tag");
   ASSERT_EQ(1U, session->windows.size());
   // Should clean up memory on its own.
 }
 
 TEST_F(SyncedSessionTrackerTest, PutTabInWindow) {
   GetTracker()->PutWindowInSession("tag", 10);
   GetTracker()->PutTabInWindow("tag", 10, 15,
                                0);  // win id 10, tab id 15, tab ind 0.
-  sync_driver::SyncedSession* session = GetTracker()->GetSession("tag");
+  SyncedSession* session = GetTracker()->GetSession("tag");
   ASSERT_EQ(1U, session->windows.size());
   ASSERT_EQ(1U, session->windows[10]->tabs.size());
   ASSERT_EQ(GetTracker()->GetTab("tag", 15, 1), session->windows[10]->tabs[0]);
   // Should clean up memory on its own.
 }
 
 TEST_F(SyncedSessionTrackerTest, LookupAllForeignSessions) {
-  std::vector<const sync_driver::SyncedSession*> sessions;
+  std::vector<const SyncedSession*> sessions;
   ASSERT_FALSE(GetTracker()->LookupAllForeignSessions(
       &sessions, SyncedSessionTracker::PRESENTABLE));
   GetTracker()->GetSession("tag1");
   GetTracker()->PutWindowInSession("tag1", 0);
   GetTracker()->PutTabInWindow("tag1", 0, 15, 0);
   sessions::SessionTab* tab = GetTracker()->GetTab("tag1", 15, 1);
   ASSERT_TRUE(tab);
   tab->navigations.push_back(
       sessions::SerializedNavigationEntryTestHelper::CreateNavigation(kValidUrl,
                                                                       "title"));
@@ skipping 59 matching lines @@
   ASSERT_EQ(1U, GetTracker()->num_synced_sessions());
   temp_tab = GetTracker()->GetTab(tag1, 0, 0);  // Already created.
   ASSERT_EQ(3U, GetTracker()->num_synced_tabs(tag1));
   ASSERT_EQ(1U, GetTracker()->num_synced_sessions());
   ASSERT_EQ(tabs1[0], temp_tab);
   tabs2.push_back(GetTracker()->GetTab(tag2, 0, 0));
   ASSERT_EQ(1U, GetTracker()->num_synced_tabs(tag2));
   ASSERT_EQ(2U, GetTracker()->num_synced_sessions());
   ASSERT_FALSE(GetTracker()->DeleteSession(tag3));
 
-  sync_driver::SyncedSession* session = GetTracker()->GetSession(tag1);
-  sync_driver::SyncedSession* session2 = GetTracker()->GetSession(tag2);
-  sync_driver::SyncedSession* session3 = GetTracker()->GetSession(tag3);
-  session3->device_type = sync_driver::SyncedSession::TYPE_OTHER;
+  SyncedSession* session = GetTracker()->GetSession(tag1);
+  SyncedSession* session2 = GetTracker()->GetSession(tag2);
+  SyncedSession* session3 = GetTracker()->GetSession(tag3);
+  session3->device_type = SyncedSession::TYPE_OTHER;
   ASSERT_EQ(3U, GetTracker()->num_synced_sessions());
 
   ASSERT_TRUE(session);
   ASSERT_TRUE(session2);
   ASSERT_TRUE(session3);
   ASSERT_NE(session, session2);
   ASSERT_NE(session2, session3);
   ASSERT_TRUE(GetTracker()->DeleteSession(tag3));
   ASSERT_EQ(2U, GetTracker()->num_synced_sessions());
 
   GetTracker()->PutWindowInSession(tag1, 0);           // Create a window.
   GetTracker()->PutTabInWindow(tag1, 0, 2, 0);         // No longer unmapped.
   ASSERT_EQ(3U, GetTracker()->num_synced_tabs(tag1));  // Has not changed.
 
   const sessions::SessionTab* tab_ptr;
   ASSERT_TRUE(GetTracker()->LookupSessionTab(tag1, 0, &tab_ptr));
   ASSERT_EQ(tab_ptr, tabs1[0]);
   ASSERT_TRUE(GetTracker()->LookupSessionTab(tag1, 2, &tab_ptr));
   ASSERT_EQ(tab_ptr, tabs1[2]);
   ASSERT_FALSE(GetTracker()->LookupSessionTab(tag1, 3, &tab_ptr));
   ASSERT_FALSE(tab_ptr);
 
   std::vector<const sessions::SessionWindow*> windows;
   ASSERT_TRUE(GetTracker()->LookupSessionWindows(tag1, &windows));
   ASSERT_EQ(1U, windows.size());
   ASSERT_TRUE(GetTracker()->LookupSessionWindows(tag2, &windows));
   ASSERT_EQ(0U, windows.size());
 
   // The sessions don't have valid tabs, lookup should not succeed.
-  std::vector<const sync_driver::SyncedSession*> sessions;
+  std::vector<const SyncedSession*> sessions;
   ASSERT_FALSE(GetTracker()->LookupAllForeignSessions(
       &sessions, SyncedSessionTracker::PRESENTABLE));
   ASSERT_TRUE(GetTracker()->LookupAllForeignSessions(
       &sessions, SyncedSessionTracker::RAW));
   ASSERT_EQ(2U, sessions.size());
 
   GetTracker()->Clear();
   ASSERT_EQ(0U, GetTracker()->num_synced_tabs(tag1));
   ASSERT_EQ(0U, GetTracker()->num_synced_tabs(tag2));
   ASSERT_EQ(0U, GetTracker()->num_synced_sessions());
@@ skipping 83 matching lines @@
   GetTracker()->LookupTabNodeIds(tag2, &result);
   EXPECT_TRUE(result.empty());
 }
 
 TEST_F(SyncedSessionTrackerTest, SessionTracking) {
   ASSERT_TRUE(GetTracker()->Empty());
   std::string tag1 = "tag1";
   std::string tag2 = "tag2";
 
   // Create some session information that is stale.
-  sync_driver::SyncedSession* session1 = GetTracker()->GetSession(tag1);
+  SyncedSession* session1 = GetTracker()->GetSession(tag1);
   GetTracker()->PutWindowInSession(tag1, 0);
   GetTracker()->PutTabInWindow(tag1, 0, 0, 0);
   GetTracker()->PutTabInWindow(tag1, 0, 1, 1);
   GetTracker()->GetTab(tag1, 2, 3U)->window_id.set_id(0);  // Will be unmapped.
   GetTracker()->GetTab(tag1, 3, 4U)->window_id.set_id(0);  // Will be unmapped.
   GetTracker()->PutWindowInSession(tag1, 1);
   GetTracker()->PutTabInWindow(tag1, 1, 4, 0);
   GetTracker()->PutTabInWindow(tag1, 1, 5, 1);
   ASSERT_EQ(2U, session1->windows.size());
   ASSERT_EQ(2U, session1->windows[0]->tabs.size());
   ASSERT_EQ(2U, session1->windows[1]->tabs.size());
   ASSERT_EQ(6U, GetTracker()->num_synced_tabs(tag1));
 
   // Create a session that should not be affected.
-  sync_driver::SyncedSession* session2 = GetTracker()->GetSession(tag2);
+  SyncedSession* session2 = GetTracker()->GetSession(tag2);
   GetTracker()->PutWindowInSession(tag2, 2);
   GetTracker()->PutTabInWindow(tag2, 2, 1, 0);
   ASSERT_EQ(1U, session2->windows.size());
   ASSERT_EQ(1U, session2->windows[2]->tabs.size());
   ASSERT_EQ(1U, GetTracker()->num_synced_tabs(tag2));
 
   // Reset tracking and get the current windows/tabs.
   // We simulate moving a tab from one window to another, then closing the
   // first window (including its one remaining tab), and opening a new tab
   // on the remaining window.
@@ skipping 46 matching lines @@
   GetTracker()->DeleteForeignTab(session_tag, tab_node_id_3);
   GetTracker()->LookupTabNodeIds(session_tag, &result);
   EXPECT_EQ(1U, result.size());
   EXPECT_TRUE(result.find(tab_node_id_4) != result.end());
 
   GetTracker()->DeleteForeignTab(session_tag, tab_node_id_4);
   GetTracker()->LookupTabNodeIds(session_tag, &result);
   EXPECT_TRUE(result.empty());
 }
 
-}  // namespace browser_sync
+}  // namespace sync_sessions