[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/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
-#include "chrome/browser/sync/glue/synced_session_util.h"
 #include "chrome/browser/sync/sessions/sessions_sync_manager.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/sync_sessions/revisit/bookmarks_by_url_provider_impl.h"
 #include "components/sync_sessions/revisit/bookmarks_page_revisit_observer.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* sessions,
+    sync_sessions::SyncSessionsClient* sessions_client,
     history::HistoryService* history,
-    bookmarks::BookmarkModel* bookmarks) {
+    bookmarks::BookmarkModel* bookmarks)
+    : 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(sessions))));
 
     revisit_observers_.push_back(
         new sync_sessions::TypedUrlPageRevisitObserver(history));
 
     revisit_observers_.push_back(
         new sync_sessions::BookmarksPageRevisitObserver(
             scoped_ptr<sync_sessions::BookmarksByUrlProvider>(
                 new sync_sessions::BookmarksByUrlProviderImpl(bookmarks))));
   }
 }
 
 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