sync: Remove ClearUserData command.

chrome/browser/sync/glue/sync_backend_host.cc

 // Copyright (c) 2012 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 "build/build_config.h"
 
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 
 #include <algorithm>
 #include <map>
@@ skipping 79 matching lines @@
   virtual void OnConnectionStatusChange(
       sync_api::ConnectionStatus status) OVERRIDE;
   virtual void OnPassphraseRequired(
       sync_api::PassphraseRequiredReason reason,
       const sync_pb::EncryptedData& pending_keys) OVERRIDE;
   virtual void OnPassphraseAccepted() OVERRIDE;
   virtual void OnBootstrapTokenUpdated(
       const std::string& bootstrap_token) OVERRIDE;
   virtual void OnStopSyncingPermanently() OVERRIDE;
   virtual void OnUpdatedToken(const std::string& token) OVERRIDE;
-  virtual void OnClearServerDataFailed() OVERRIDE;
-  virtual void OnClearServerDataSucceeded() OVERRIDE;
   virtual void OnEncryptedTypesChanged(
       syncable::ModelTypeSet encrypted_types,
       bool encrypt_everything) OVERRIDE;
   virtual void OnEncryptionComplete() OVERRIDE;
   virtual void OnActionableError(
       const browser_sync::SyncProtocolError& sync_error) OVERRIDE;
 
   // Note:
   //
   // The Do* methods are the various entry points from our
   // SyncBackendHost.  They are all called on the sync thread to
   // actually perform synchronous (and potentially blocking) syncapi
   // operations.
   //
   // Called to perform initialization of the syncapi on behalf of
   // SyncBackendHost::Initialize.
   void DoInitialize(const DoInitializeOptions& options);
 
   // Called to perform credential update on behalf of
   // SyncBackendHost::UpdateCredentials
   void DoUpdateCredentials(const sync_api::SyncCredentials& credentials);
 
   // Called when the user disables or enables a sync type.
   void DoUpdateEnabledTypes(const syncable::ModelTypeSet& enabled_types);
 
   // Called to tell the syncapi to start syncing (generally after
   // initialization and authentication).
   void DoStartSyncing(const ModelSafeRoutingInfo& routing_info);
 
-  // Called to clear server data.
-  void DoRequestClearServerData();
-
   // Called to cleanup disabled types.
   void DoRequestCleanupDisabledTypes(
       const browser_sync::ModelSafeRoutingInfo& routing_info);
 
   // Called to set the passphrase for encryption.
   void DoSetEncryptionPassphrase(const std::string& passphrase,
                                  bool is_explicit);
 
   // Called to decrypt the pending keys.
   void DoSetDecryptionPassphrase(const std::string& passphrase);
@@ skipping 477 matching lines @@
 void SyncBackendHost::ActivateDataType(
     syncable::ModelType type, ModelSafeGroup group,
     ChangeProcessor* change_processor) {
   registrar_->ActivateDataType(type, group, change_processor, GetUserShare());
 }
 
 void SyncBackendHost::DeactivateDataType(syncable::ModelType type) {
   registrar_->DeactivateDataType(type);
 }
 
-bool SyncBackendHost::RequestClearServerData() {
-  sync_thread_.message_loop()->PostTask(FROM_HERE,
-      base::Bind(&SyncBackendHost::Core::DoRequestClearServerData,
-                 core_.get()));
-  return true;
-}
-
 sync_api::UserShare* SyncBackendHost::GetUserShare() const {
   DCHECK(initialized());
   return core_->sync_manager()->GetUserShare();
 }
 
 SyncBackendHost::Status SyncBackendHost::GetDetailedStatus() {
   DCHECK(initialized());
   return core_->sync_manager()->GetDetailedStatus();
 }
 
@@ skipping 333 matching lines @@
 
 void SyncBackendHost::Core::OnUpdatedToken(const std::string& token) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::NotifyUpdatedToken, token);
 }
 
-void SyncBackendHost::Core::OnClearServerDataFailed() {
-  if (!sync_loop_)
-    return;
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHost::HandleClearServerDataFailedOnFrontendLoop);
-}
-
-void SyncBackendHost::Core::OnClearServerDataSucceeded() {
-  if (!sync_loop_)
-    return;
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  host_.Call(
-      FROM_HERE,
-      &SyncBackendHost::HandleClearServerDataSucceededOnFrontendLoop);
-}
-
 void SyncBackendHost::Core::OnEncryptedTypesChanged(
     syncable::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   // NOTE: We're in a transaction.
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::NotifyEncryptedTypesChanged,
@@ skipping 122 matching lines @@
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->UpdateEnabledTypes(enabled_types);
 }
 
 void SyncBackendHost::Core::DoStartSyncing(
     const ModelSafeRoutingInfo& routing_info) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->StartSyncingNormally(routing_info);
 }
 
-void SyncBackendHost::Core::DoRequestClearServerData() {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  sync_manager_->RequestClearServerData();
-}
-
 void SyncBackendHost::Core::DoRequestCleanupDisabledTypes(
     const browser_sync::ModelSafeRoutingInfo& routing_info) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->RequestCleanupDisabledTypes(routing_info);
 }
 
 void SyncBackendHost::Core::DoSetEncryptionPassphrase(
     const std::string& passphrase,
     bool is_explicit) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
@@ skipping 248 matching lines @@
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
   frontend_->OnEncryptionComplete();
 }
 
 void SyncBackendHost::HandleStopSyncingPermanentlyOnFrontendLoop() {
   if (!frontend_)
     return;
   frontend_->OnStopSyncingPermanently();
 }
 
-void SyncBackendHost::HandleClearServerDataSucceededOnFrontendLoop() {
-  if (!frontend_)
-    return;
-  frontend_->OnClearServerDataSucceeded();
-}
-
-void SyncBackendHost::HandleClearServerDataFailedOnFrontendLoop() {
-  if (!frontend_)
-    return;
-  frontend_->OnClearServerDataFailed();
-}
-
 void SyncBackendHost::HandleConnectionStatusChangeOnFrontendLoop(
     sync_api::ConnectionStatus status) {
   if (!frontend_)
     return;
 
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
 
   frontend_->OnConnectionStatusChange(status);
 }
 
@@ skipping 24 matching lines @@
       FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoRefreshNigori,
                  core_.get(), sync_thread_done_callback));
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync