[sync] WebContentsObserver based sessions notifications

components/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 <stdint.h>
 
 #include <utility>
 
@@ skipping 193 matching lines @@
     int http_count = 0;
     for (auto& entry : entries_) {
       if (!entry->virtual_url().is_valid())
         return false;
       if (entry->virtual_url().SchemeIsHTTPOrHTTPS())
         http_count++;
     }
     return http_count > 0;
   }
 
+  SessionID::id_type GetSourceTabID() const override { return -1; }

[Nicolas Zea, 2017/03/16 19:57:44]

Would it be possible to use kUnknownTabId here 
(and below)?

[Patrick Noland, 2017/03/16 20:23:27]

Done.

+
   void AppendEntry(std::unique_ptr<sessions::SerializedNavigationEntry> entry) {
     entries_.push_back(std::move(entry));
   }
 
   void set_current_entry_index(int i) { current_entry_index_ = i; }
 
   void SetWindowId(SessionID::id_type window_id) {
     window_id_.set_id(window_id);
   }
 
@@ skipping 91 matching lines @@
   const std::vector<std::unique_ptr<const sessions::SerializedNavigationEntry>>*
   GetBlockedNavigations() const override {
     NOTREACHED();
     return nullptr;
   }
   bool ShouldSync(SyncSessionsClient* sessions_client) override {
     NOTREACHED();
     return false;
   }
 
+  SessionID::id_type GetSourceTabID() const override { return -1; }
+
  private:
   SessionID::id_type session_id_;
   int sync_id_;
 };
 
 class TestSyncedWindowDelegate : public SyncedWindowDelegate {
  public:
   TestSyncedWindowDelegate() {}
   ~TestSyncedWindowDelegate() override {}
 
@@ skipping 170 matching lines @@
 
   void SetUp() override {
     local_device_ = base::MakeUnique<LocalDeviceInfoProviderMock>(
         "cache_guid", "Wayne Gretzky's Hacking Box", "Chromium 10k",
         "Chrome 10k", sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id");
     sync_client_ = base::MakeUnique<syncer::FakeSyncClient>();
     sessions_client_shim_ =
         base::MakeUnique<SyncSessionsClientShim>(&window_getter_);
     sync_prefs_ =
         base::MakeUnique<syncer::SyncPrefs>(sync_client_->GetPrefService());
+    router_ = base::MakeUnique<DummyRouter>();
     manager_ = base::MakeUnique<SessionsSyncManager>(
         sessions_client_shim(), sync_prefs_.get(), local_device_.get(),
-        std::unique_ptr<LocalSessionEventRouter>(NewDummyRouter()),
+        router_.get(),
         base::Bind(&SessionNotificationObserver::NotifyOfUpdate,
                    base::Unretained(&observer_)),
         base::Bind(&SessionNotificationObserver::NotifyOfRefresh,
                    base::Unretained(&observer_)));
   }
 
   void TearDown() override {
     test_processor_ = nullptr;
     helper()->Reset();
     sync_prefs_.reset();
@@ skipping 11 matching lines @@
   SessionsSyncManager* manager() { return manager_.get(); }
   SessionSyncTestHelper* helper() { return &helper_; }
   LocalDeviceInfoProvider* local_device() { return local_device_.get(); }
   SessionNotificationObserver* observer() { return &observer_; }
   syncer::SyncPrefs* sync_prefs() { return sync_prefs_.get(); }
   SyncSessionsClient* sessions_client_shim() {
     return sessions_client_shim_.get();
   }
   SyncedWindowDelegatesGetter* window_getter() { return &window_getter_; }
 
-  std::unique_ptr<LocalSessionEventRouter> NewDummyRouter() {
-    std::unique_ptr<DummyRouter> router(new DummyRouter());
-    router_ = router.get();
-    return std::unique_ptr<LocalSessionEventRouter>(std::move(router));
-  }
-
   void InitWithSyncDataTakeOutput(const SyncDataList& initial_data,
                                   SyncChangeList* output) {
     test_processor_ = new TestSyncChangeProcessor(output);
     syncer::SyncMergeResult result = manager_->MergeDataAndStartSyncing(
         syncer::SESSIONS, initial_data,
         std::unique_ptr<syncer::SyncChangeProcessor>(test_processor_),
         std::unique_ptr<syncer::SyncErrorFactory>(
             new syncer::SyncErrorFactoryMock()));
     EXPECT_FALSE(result.error().IsSet());
   }
@@ skipping 156 matching lines @@
     windows_.push_back(base::MakeUnique<TestSyncedWindowDelegate>());
     window_getter_.AddSyncedWindowDelegate(windows_.back().get());
     return windows_.back().get();
   }
 
  private:
   std::unique_ptr<syncer::FakeSyncClient> sync_client_;
   std::unique_ptr<SyncSessionsClientShim> sessions_client_shim_;
   std::unique_ptr<syncer::SyncPrefs> sync_prefs_;
   SessionNotificationObserver observer_;
-  DummyRouter* router_ = nullptr;
+  std::unique_ptr<DummyRouter> router_;
   std::unique_ptr<SessionsSyncManager> manager_;
   SessionSyncTestHelper helper_;
   TestSyncChangeProcessor* test_processor_ = nullptr;
   TestSyncedWindowDelegatesGetter window_getter_;
   std::vector<std::unique_ptr<TestSyncedWindowDelegate>> windows_;
   std::vector<std::unique_ptr<TestSyncedTabDelegate>> tabs_;
   std::unique_ptr<LocalDeviceInfoProviderMock> local_device_;
 };
 
 // Test that the SyncSessionManager can properly fill in a SessionHeader.
@@ skipping 1655 matching lines @@
   // Because tab 2 is a placeholder, tab 1's URL will be preserved.
   VerifyLocalTabChange(out[1], 1, kFoo1);
   EXPECT_EQ(sync_id, out[1].sync_data().GetSpecifics().session().tab_node_id());
   EXPECT_EQ(tab2.GetSessionId(),
             out[1].sync_data().GetSpecifics().session().tab().tab_id());
   EXPECT_EQ(window2->GetSessionId(),
             out[1].sync_data().GetSpecifics().session().tab().window_id());
 }
 
 }  // namespace sync_sessions