Add shutdown notification and service refs to SyncServiceObserver.

components/ntp_snippets/sessions/tab_delegate_sync_adapter.cc

 // Copyright 2016 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/ntp_snippets/sessions/tab_delegate_sync_adapter.h"
 
 #include "components/sync/driver/sync_service.h"
 #include "components/sync_sessions/open_tabs_ui_delegate.h"
 
 using syncer::SyncService;
@@ skipping 26 matching lines @@
   }
   return sessions;
 }
 
 void TabDelegateSyncAdapter::SubscribeForForeignTabChange(
     const base::Closure& change_callback) {
   DCHECK(change_callback_.is_null());
   change_callback_ = change_callback;
 }
 
-void TabDelegateSyncAdapter::OnStateChanged() {
+void TabDelegateSyncAdapter::OnStateChanged(syncer::SyncService* sync) {
   // OnStateChanged gets called very frequently, and usually is not important.
   // But there are some events, like disabling sync and signing out, that are
   // only captured through OnStateChange. In an attempt to send as few messages
   // as possible, track if there was session data, and always/only invoke the
   // callback when transitioning between states. This will also capture the case
   // when Open Tab is added/removed from syncing types. Note that this requires
   // the object behind GetOpenTabsUIDelegate() to have its real data when it
   // becomes available. Otherwise we might transition to think we have session
   // data, but invoke our callback while the GetOpenTabsUIDelegate() returns bad
   // results. Fortunately, this isn't a problem. GetOpenTabsUIDelegate() is
   // guarded by verifying the data type is RUNNING, which always means the
   // sessions merge has already happened.
   if (had_session_data_ != HasSessionsData()) {
     InvokeCallback();
   }
 }
 
-void TabDelegateSyncAdapter::OnSyncConfigurationCompleted() {
+void TabDelegateSyncAdapter::OnSyncConfigurationCompleted(
+    syncer::SyncService* sync) {
   // Ignored. This event can let us know when the set of enabled data types
   // change. However, we want to avoid useless notifications as much as
   // possible, and all of the information captured in this event will also be
   // covered by OnStateChange.
 }
 
-void TabDelegateSyncAdapter::OnForeignSessionUpdated() {
+void TabDelegateSyncAdapter::OnForeignSessionUpdated(
+    syncer::SyncService* sync) {
   // Foreign tab data changed, always invoke the callback to generate new
   // suggestions. Interestingly, this is only triggered after sync model type
   // apply, not after merge. The merge case should always be handled by
   // OnStateChange.
   InvokeCallback();
 }
 
 void TabDelegateSyncAdapter::InvokeCallback() {
   had_session_data_ = HasSessionsData();
   if (!change_callback_.is_null()) {
     change_callback_.Run();
   }
 }
 
 }  // namespace ntp_snippets