[Sync] Componentize synced_tab_delegate

chrome/browser/sync/sessions/page_revisit_broadcaster.cc

 // 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.
 
 #include "chrome/browser/sync/sessions/page_revisit_broadcaster.h"
 
 #include <string>
 #include <vector>
 
 #include "base/metrics/field_trial.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/sync/glue/synced_session_util.h"
 #include "chrome/browser/sync/sessions/sessions_sync_manager.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/sync_sessions/revisit/sessions_page_revisit_observer.h"
 #include "components/sync_sessions/revisit/typed_url_page_revisit_observer.h"
+#include "components/sync_sessions/sync_sessions_client.h"
 
 namespace browser_sync {
 
 namespace {
 
 // Simple implementation of ForeignSessionsProvider that delegates to
 // SessionsSyncManager. It holds onto a non-owning pointer, with the assumption
 // that this class is only used by classes owned by SessionsSyncManager itself.
 class SessionsSyncManagerWrapper
     : public sync_sessions::ForeignSessionsProvider {
  public:
   explicit SessionsSyncManagerWrapper(SessionsSyncManager* manager)
       : manager_(manager) {}
   ~SessionsSyncManagerWrapper() override{};
   bool GetAllForeignSessions(
       std::vector<const sync_driver::SyncedSession*>* sessions) override {
     return manager_->GetAllForeignSessions(sessions);
   }
 
  private:
   SessionsSyncManager* manager_;
   DISALLOW_COPY_AND_ASSIGN(SessionsSyncManagerWrapper);
 };
 
 }  // namespace
 
-PageRevisitBroadcaster::PageRevisitBroadcaster(SessionsSyncManager* manager,
-                                               Profile* profile) {
+PageRevisitBroadcaster::PageRevisitBroadcaster(
+    SessionsSyncManager* manager,
+    sync_sessions::SyncSessionsClient* sessions_client,
+    Profile* profile)
+    : sessions_client_(sessions_client) {
   const std::string group_name =
       base::FieldTrialList::FindFullName("PageRevisitInstrumentation");
   bool shouldInstrument = group_name == "Enabled";
   if (shouldInstrument) {
     revisit_observers_.push_back(new sync_sessions::SessionsPageRevisitObserver(
         scoped_ptr<sync_sessions::ForeignSessionsProvider>(
             new SessionsSyncManagerWrapper(manager))));
 
     history::HistoryService* history =
         HistoryServiceFactory::GetForProfileWithoutCreating(profile);
     if (history) {
       revisit_observers_.push_back(
           new sync_sessions::TypedUrlPageRevisitObserver(history));
     }
     // TODO(skym): Add bookmarks observer.
   }
 }
 
 PageRevisitBroadcaster::~PageRevisitBroadcaster() {}
 
 void PageRevisitBroadcaster::OnPageVisit(const GURL& url,
                                          const ui::PageTransition transition) {
-  if (ShouldSyncURL(url)) {
+  if (sessions_client_->ShouldSyncURL(url)) {
     sync_sessions::PageVisitObserver::TransitionType converted(
         ConvertTransitionEnum(transition));
     for (auto* observer : revisit_observers_) {
       observer->OnPageVisit(url, converted);
     }
   }
 }
 
 // Static
 sync_sessions::PageVisitObserver::TransitionType
@@ skipping 38 matching lines @@
     case ui::PAGE_TRANSITION_KEYWORD:
     case ui::PAGE_TRANSITION_KEYWORD_GENERATED:
       return sync_sessions::PageVisitObserver::kTransitionOmniboxTemplateSearch;
 
     default:
       return sync_sessions::PageVisitObserver::kTransitionUnknown;
   }
 }
 
 }  // namespace browser_sync