NOT FOR REVIEW

components/wifi_sync/wifi_credential_syncable_service_impl.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/wifi_sync/wifi_credential_syncable_service_impl.h"
 
 #include <stdint.h>
 #include <vector>
 
 #include "base/logging.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
 #include "components/wifi_sync/wifi_credential.h"
 #include "components/wifi_sync/wifi_security_class.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_error.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/api/sync_merge_result.h"
 #include "sync/protocol/sync.pb.h"
 
 namespace wifi_sync {
@@ skipping 72 matching lines @@
   if (sync_data.GetDataType() != syncer::WIFI_CREDENTIALS) {
     LOG(WARNING) << "Unexpected SyncData of type "
                  << syncer::ModelTypeToString(sync_data.GetDataType())
                  << "; skipping item";
     return false;
   }
 
   return ParseSpecifics(sync_data.GetSpecifics(), raw_credential);
 }
 
+std::string ComputeItemId(const WifiCredential credential) {
+  return base::StringPrintf(
+      "%s:%d",
+      base::HexEncode(credential.ssid().data(),
+                      credential.ssid().size()).c_str(),
+      credential.security_class());
+}
+
 }  // namespace
 
 const syncer::ModelType WifiCredentialSyncableServiceImpl::kModelType =
     syncer::WIFI_CREDENTIALS;
 
 WifiCredentialSyncableServiceImpl::WifiCredentialSyncableServiceImpl(
-    scoped_ptr<WifiConfigDelegate> network_config_delegate)
-    : network_config_delegate_(network_config_delegate.Pass()) {
+    scoped_ptr<WifiConfigDelegate> network_config_delegate,
+    scoped_ptr<WifiConfigObserver> network_config_observer)
+    : network_config_delegate_(network_config_delegate.Pass()),
+      network_config_observer_(network_config_observer.Pass()) {
   DCHECK(network_config_delegate_);
+  DCHECK(network_config_observer_);
 }
 
 WifiCredentialSyncableServiceImpl::~WifiCredentialSyncableServiceImpl() {
 }
 
 syncer::SyncMergeResult WifiCredentialSyncableServiceImpl::MergeDataAndStartSyncing(
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
     scoped_ptr<syncer::SyncErrorFactory> /* error_handler */) {
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
   DCHECK_EQ(kModelType, type);
 
   sync_processor_ = sync_processor.Pass();
 
   // TODO(quiche): Update local WiFi configuration from |initial_sync_data|.
-  // TODO(quiche): Notify upper layers that sync is ready.
   NOTIMPLEMENTED();
 
+  network_config_observer_->StartSyncing(base::AsWeakPtr(this));
   return syncer::SyncMergeResult(type);
 }
 
 void WifiCredentialSyncableServiceImpl::StopSyncing(syncer::ModelType type) {
   DCHECK_EQ(kModelType, type);
+  network_config_observer_->StopSyncing();
   sync_processor_.reset();
 }
 
 syncer::SyncDataList WifiCredentialSyncableServiceImpl::GetAllSyncData(
     syncer::ModelType type) const {
   DCHECK_EQ(kModelType, type);
   NOTIMPLEMENTED();
   return syncer::SyncDataList();
 }
 
@@ skipping 40 matching lines @@
         return syncer::SyncError(
             FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
             "ProcessSyncChanges given invalid SyncChangeType", kModelType);
     }
   }
 
   return syncer::SyncError();
 }
 
 bool WifiCredentialSyncableServiceImpl::AddToSyncedNetworks(
-    const std::string& item_id,
     const WifiCredential& credential) {
   if (!sync_processor_.get()) {
     // Callers must queue updates until MergeDataAndStartSyncing has
     // been called on this SyncableService.
     LOG(WARNING) << "WifiCredentials syncable service is not started.";
     return false;
   }
 
   const SsidAndSecurityClass network_id(
       credential.ssid(), credential.security_class());
   if (synced_networks_and_passphrases_.find(network_id) !=
       synced_networks_and_passphrases_.end()) {
     // TODO(quiche): If passphrase has changed, submit this to sync as
     // an ACTION_UPDATE. crbug.com/431436
     return false;
   }
 
   syncer::SyncChangeList change_list;
   syncer::SyncError sync_error;
   sync_pb::EntitySpecifics wifi_credential_specifics;
+  std::string item_id(ComputeItemId(credential));
   BuildSpecifics(credential, &wifi_credential_specifics);
   change_list.push_back(
       syncer::SyncChange(FROM_HERE, syncer::SyncChange::ACTION_ADD,
                          syncer::SyncData::CreateLocalData(
                              item_id, item_id, wifi_credential_specifics)));
   sync_error = sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
   if (sync_error.IsSet()) {
     LOG(ERROR) << sync_error.ToString();
     return false;
   }
 
   synced_networks_and_passphrases_[network_id] = credential.passphrase();
   return true;
 }
 
 }  // namespace wifi_sync