[Sync] Fix namespaces for the sync_sessions component.

chrome/browser/sync/sessions/sessions_sync_manager_unittest.cc

 // Copyright 2014 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/sessions_sync_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/sync/chrome_sync_client.h"
-#include "chrome/browser/sync/glue/session_sync_test_helper.h"
 #include "chrome/browser/sync/sessions/notification_service_sessions_router.h"
 #include "chrome/browser/ui/sync/browser_synced_window_delegates_getter.h"
 #include "chrome/browser/ui/sync/tab_contents_synced_tab_delegate.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
 #include "components/sessions/content/content_serialized_navigation_builder.h"
 #include "components/sessions/core/serialized_navigation_entry_test_helper.h"
 #include "components/sessions/core/session_id.h"
 #include "components/sessions/core/session_types.h"
 #include "components/sync/api/attachments/attachment_id.h"
 #include "components/sync/api/sync_error_factory_mock.h"
 #include "components/sync/core/attachments/attachment_service_proxy_for_test.h"
 #include "components/sync/device_info/device_info.h"
 #include "components/sync/device_info/local_device_info_provider_mock.h"
 #include "components/sync/driver/sync_api_component_factory.h"
+#include "components/sync_sessions/session_sync_test_helper.h"
 #include "components/sync_sessions/sync_sessions_client.h"
 #include "components/sync_sessions/synced_tab_delegate.h"
 #include "components/sync_sessions/synced_window_delegate.h"
 #include "components/sync_sessions/synced_window_delegates_getter.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/web_contents.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::WebContents;
 using sessions::SerializedNavigationEntry;
 using sessions::SerializedNavigationEntryTestHelper;
 using sync_driver::DeviceInfo;
 using sync_driver::LocalDeviceInfoProvider;
 using sync_driver::LocalDeviceInfoProviderMock;
-using sync_driver::SyncedSession;
 using syncer::SyncChange;
 using syncer::SyncData;
 
-namespace browser_sync {
+namespace sync_sessions {
 
 namespace {
 
 class SessionNotificationObserver {
  public:
   SessionNotificationObserver()
       : notified_of_update_(false), notified_of_refresh_(false) {}
   void NotifyOfUpdate() { notified_of_update_ = true; }
   void NotifyOfRefresh() { notified_of_refresh_ = true; }
 
@@ skipping 140 matching lines @@
 }
 
 int CountIfTagMatches(const syncer::SyncChangeList& changes,
                       const std::string& tag) {
   return std::count_if(
       changes.begin(), changes.end(), [&tag](const syncer::SyncChange& change) {
         return change.sync_data().GetSpecifics().session().session_tag() == tag;
       });
 }
 
-int CountIfTagMatches(
-    const std::vector<const sync_driver::SyncedSession*>& sessions,
-    const std::string& tag) {
+int CountIfTagMatches(const std::vector<const SyncedSession*>& sessions,
+                      const std::string& tag) {
   return std::count_if(sessions.begin(), sessions.end(),
-                       [&tag](const sync_driver::SyncedSession* session) {
+                       [&tag](const SyncedSession* session) {
                          return session->session_tag == tag;
                        });
 }
 
 // Creates a field trial with the specified |trial_name| and |group_name| and
 // registers an associated |variation_id| for it for the given |service|.
 void CreateAndActivateFieldTrial(const std::string& trial_name,
                                  const std::string& group_name,
                                  variations::VariationID variation_id,
                                  variations::IDCollectionKey service) {
@@ skipping 10 matching lines @@
   void StartRoutingTo(LocalSessionEventHandler* handler) override {}
   void Stop() override {}
 };
 
 std::unique_ptr<LocalSessionEventRouter> NewDummyRouter() {
   return std::unique_ptr<LocalSessionEventRouter>(new DummyRouter());
 }
 
 // Provides ability to override SyncedWindowDelegatesGetter.
 // All other calls are passed through to the original SyncSessionsClient.
-class SyncSessionsClientShim : public sync_sessions::SyncSessionsClient {
+class SyncSessionsClientShim : public SyncSessionsClient {
  public:
-  SyncSessionsClientShim(
-      sync_sessions::SyncSessionsClient* sync_sessions_client)
+  explicit SyncSessionsClientShim(SyncSessionsClient* sync_sessions_client)
       : sync_sessions_client_(sync_sessions_client),
         synced_window_getter_(nullptr) {}
   ~SyncSessionsClientShim() override {}
 
   bookmarks::BookmarkModel* GetBookmarkModel() override {
     return sync_sessions_client_->GetBookmarkModel();
   }
 
   favicon::FaviconService* GetFaviconService() override {
     return sync_sessions_client_->GetFaviconService();
   }
 
   history::HistoryService* GetHistoryService() override {
     return sync_sessions_client_->GetHistoryService();
   }
 
   bool ShouldSyncURL(const GURL& url) const override {
     return sync_sessions_client_->ShouldSyncURL(url);
   }
 
-  browser_sync::SyncedWindowDelegatesGetter* GetSyncedWindowDelegatesGetter()
-      override {
+  SyncedWindowDelegatesGetter* GetSyncedWindowDelegatesGetter() override {
     // The idea here is to allow the test code override the default
     // SyncedWindowDelegatesGetter provided by |sync_sessions_client_|.
     // If |synced_window_getter_| is explicitly set, return it; otherwise return
     // the default one provided by |sync_sessions_client_|.
     return synced_window_getter_
                ? synced_window_getter_
                : sync_sessions_client_->GetSyncedWindowDelegatesGetter();
   }
 
-  std::unique_ptr<browser_sync::LocalSessionEventRouter>
-  GetLocalSessionEventRouter() override {
+  std::unique_ptr<LocalSessionEventRouter> GetLocalSessionEventRouter()
+      override {
     return sync_sessions_client_->GetLocalSessionEventRouter();
   }
 
   void set_synced_window_getter(
-      browser_sync::SyncedWindowDelegatesGetter* synced_window_getter) {
+      SyncedWindowDelegatesGetter* synced_window_getter) {
     synced_window_getter_ = synced_window_getter;
   }
 
  private:
-  sync_sessions::SyncSessionsClient* const sync_sessions_client_;
-  browser_sync::SyncedWindowDelegatesGetter* synced_window_getter_;
+  SyncSessionsClient* const sync_sessions_client_;
+  SyncedWindowDelegatesGetter* synced_window_getter_;
 };
 
 }  // namespace
 
 class SessionsSyncManagerTest
     : public BrowserWithTestWindowTest {
  protected:
   SessionsSyncManagerTest()
       : test_processor_(NULL) {
     local_device_.reset(new LocalDeviceInfoProviderMock(
         "cache_guid",
         "Wayne Gretzky's Hacking Box",
         "Chromium 10k",
         "Chrome 10k",
         sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
         "device_id"));
   }
 
   void SetUp() override {
     BrowserWithTestWindowTest::SetUp();
     sync_client_.reset(new browser_sync::ChromeSyncClient(profile()));
     sessions_client_shim_.reset(
         new SyncSessionsClientShim(sync_client_->GetSyncSessionsClient()));
-    browser_sync::NotificationServiceSessionsRouter* router(
-        new browser_sync::NotificationServiceSessionsRouter(
+    NotificationServiceSessionsRouter* router(
+        new NotificationServiceSessionsRouter(
             profile(), GetSyncSessionsClient(),
             syncer::SyncableService::StartSyncFlare()));
     sync_prefs_.reset(new sync_driver::SyncPrefs(profile()->GetPrefs()));
     manager_.reset(new SessionsSyncManager(
         GetSyncSessionsClient(), sync_prefs_.get(), local_device_.get(),
         std::unique_ptr<LocalSessionEventRouter>(router),
         base::Bind(&SessionNotificationObserver::NotifyOfUpdate,
                    base::Unretained(&observer_)),
         base::Bind(&SessionNotificationObserver::NotifyOfRefresh,
                    base::Unretained(&observer_))));
@@ skipping 54 matching lines @@
         it = list->erase(it);
         found = true;
       } else {
         ++it;
       }
     }
     EXPECT_TRUE(found);
     return list;
   }
 
-  sync_sessions::SyncSessionsClient* GetSyncSessionsClient() {
+  SyncSessionsClient* GetSyncSessionsClient() {
     return sessions_client_shim_.get();
   }
 
   sync_driver::SyncPrefs* sync_prefs() { return sync_prefs_.get(); }
 
-  browser_sync::SyncedWindowDelegatesGetter* get_synced_window_getter() {
+  SyncedWindowDelegatesGetter* get_synced_window_getter() {
     return manager()->synced_window_delegates_getter();
   }
 
   void set_synced_window_getter(
-      browser_sync::SyncedWindowDelegatesGetter* synced_window_getter) {
+      SyncedWindowDelegatesGetter* synced_window_getter) {
     sessions_client_shim_->set_synced_window_getter(synced_window_getter);
   }
 
   syncer::SyncChange MakeRemoteChange(
       const sync_pb::SessionSpecifics& specifics,
       SyncChange::SyncChangeType type) const {
     return syncer::SyncChange(FROM_HERE, type, CreateRemoteData(specifics));
   }
 
   void AddTabsToChangeList(const std::vector<sync_pb::SessionSpecifics>& batch,
@@ skipping 154 matching lines @@
               blocked_navigations_.size(), *entry);
       blocked_navigations_.push_back(serialized_entry.release());
     }
   }
   bool IsPlaceholderTab() const override { return true; }
 
   // Session sync related methods.
   int GetSyncId() const override { return sync_id_; }
   void SetSyncId(int sync_id) override { sync_id_ = sync_id; }
 
-  bool ShouldSync(sync_sessions::SyncSessionsClient* sessions_client) override {
+  bool ShouldSync(SyncSessionsClient* sessions_client) override {
     return false;
   }
 
   void reset() {
     current_entry_index_ = 0;
     sync_id_ = -1;
     entries_.clear();
   }
 
  private:
@@ skipping 1182 matching lines @@
       1, entity, base::Time(), syncer::AttachmentIdList(),
       syncer::AttachmentServiceProxyForTest::Create(), "bad_tab_tag_hash"));
 
   syncer::SyncChangeList output;
   InitWithSyncDataTakeOutput(foreign_data, &output);
   ASSERT_EQ(2U, FilterOutLocalHeaderChanges(&output)->size());
   ExpectAllOfChangesType(output, SyncChange::ACTION_DELETE);
   EXPECT_EQ(1, CountIfTagMatches(output, bad_header_tag));
   EXPECT_EQ(1, CountIfTagMatches(output, bad_tab_tag));
 
-  std::vector<const sync_driver::SyncedSession*> sessions;
+  std::vector<const SyncedSession*> sessions;
   manager()->session_tracker_.LookupAllForeignSessions(
       &sessions, SyncedSessionTracker::RAW);
   ASSERT_EQ(2U, sessions.size());
   EXPECT_EQ(1, CountIfTagMatches(sessions, good_header_tag));
   EXPECT_EQ(1, CountIfTagMatches(sessions, good_tag_tab));
 }
 
 // Test that things work if a tab is initially ignored.
 TEST_F(SessionsSyncManagerTest, AssociateWindowsDontReloadTabs) {
   syncer::SyncChangeList out;
@@ skipping 804 matching lines @@
   ASSERT_EQ(tab_list1.size() + tab_list2.size(), tabs.size());
   base::Time last_time;
   for (size_t i = 0; i < tabs.size(); ++i) {
     base::Time this_time = tabs[i]->timestamp;
     if (i > 0)
       ASSERT_GE(last_time, this_time);
     last_time = tabs[i]->timestamp;
   }
 }
 
-}  // namespace browser_sync
+}  // namespace sync_sessions