NOT FOR REVIEW

components/wifi_sync/wifi_credential_syncable_service_impl.h

 // 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.
 
 #ifndef COMPONENTS_WIFI_SYNC_WIFI_CREDENTIAL_SYNCABLE_SERVICE_IMPL_H_
 #define COMPONENTS_WIFI_SYNC_WIFI_CREDENTIAL_SYNCABLE_SERVICE_IMPL_H_
 
 #include "components/wifi_sync/wifi_credential_syncable_service.h"
 
 #include <map>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/wifi_sync/wifi_config_delegate.h"
+#include "components/wifi_sync/wifi_config_observer.h"
 #include "components/wifi_sync/wifi_credential.h"
 #include "components/wifi_sync/wifi_security_class.h"
 #include "sync/api/sync_change_processor.h"
 
 namespace wifi_sync {
 
 // This service does not necessarily own the storage for WiFi
 // credentials. In particular, on ChromeOS, WiFi credential storage is
 // managed by the ChromeOS connection manager ("Shill").
 //
 // On ChromeOS, this class should only be instantiated
 // for the primary user profile, as that is the only profile for
 // which a Shill profile is loaded.
 class WifiCredentialSyncableServiceImpl
     : public WifiCredentialSyncableService {
  public:
   // Constructs a syncable service. Changes from Chrome Sync will be
   // applied locally by |network_config_delegate|. Local changes will
   // be propagated to Chrome Sync using the |sync_processor| provided
   // in the call to MergeDataAndStartSyncing.
-  explicit WifiCredentialSyncableServiceImpl(
-      scoped_ptr<WifiConfigDelegate> network_config_delegate);
+  WifiCredentialSyncableServiceImpl(
+      scoped_ptr<WifiConfigDelegate> network_config_delegate,
+      scoped_ptr<WifiConfigObserver> network_config_observer);
   ~WifiCredentialSyncableServiceImpl() override;
 
   // syncer::SyncableService implementation.
   syncer::SyncMergeResult MergeDataAndStartSyncing(
       syncer::ModelType type,
       const syncer::SyncDataList& initial_sync_data,
       scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
       scoped_ptr<syncer::SyncErrorFactory> error_handler) override;
   void StopSyncing(syncer::ModelType type) override;
   syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const override;
   syncer::SyncError ProcessSyncChanges(
       const tracked_objects::Location& caller_location,
       const syncer::SyncChangeList& change_list) override;
 
   // WifiCredentialSyncableService implementation.
-  bool AddToSyncedNetworks(const std::string& item_id,
-                           const WifiCredential& credential) override;
+  bool AddToSyncedNetworks(const WifiCredential& credential) override;
 
  private:
   using SsidAndSecurityClass =
       std::pair<WifiCredential::SsidBytes, WifiSecurityClass>;
   using SsidAndSecurityClassToPassphrase =
       std::map<SsidAndSecurityClass, std::string>;
 
   // The syncer::ModelType that this SyncableService processes and
   // generates updates for.
   static const syncer::ModelType kModelType;
 
   // The object we use to change local network configuration.
   const scoped_ptr<WifiConfigDelegate> network_config_delegate_;
 
+  // The object that informs us about changes to local network
+  // configuration.
+  const scoped_ptr<WifiConfigObserver> network_config_observer_;
+
   // Our SyncChangeProcessor instance. Used to push changes into
   // Chrome Sync.
   scoped_ptr<syncer::SyncChangeProcessor> sync_processor_;
 
   // The networks and passphrases that are already known by Chrome
   // Sync. All synced networks must be included in this map, even if
   // they do not use passphrases.
   SsidAndSecurityClassToPassphrase synced_networks_and_passphrases_;
 
   DISALLOW_COPY_AND_ASSIGN(WifiCredentialSyncableServiceImpl);
 };
 
 }  // namespace wifi_sync
 
 #endif  // COMPONENTS_WIFI_SYNC_WIFI_CREDENTIAL_SYNCABLE_SERVICE_IMPL_H_