[Sync] Remove ScopedServerStatusWatcher

sync/test/engine/mock_connection_manager.cc

 // Copyright 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.
 //
 // Mock ServerConnectionManager class for use in client regression tests.
 
 #include "sync/test/engine/mock_connection_manager.h"
 
 #include <map>
 
@@ skipping 30 matching lines @@
       conflict_n_commits_(0),
       next_new_id_(10000),
       store_birthday_("Store BDay!"),
       store_birthday_sent_(false),
       client_stuck_(false),
       countdown_to_postbuffer_fail_(0),
       directory_(directory),
       mid_commit_observer_(NULL),
       throttling_(false),
       partialThrottling_(false),
-      fail_with_auth_invalid_(false),
       fail_non_periodic_get_updates_(false),
       next_position_in_parent_(2),
       use_legacy_bookmarks_protocol_(false),
       num_get_updates_requests_(0) {
   SetNewTimestamp(0);
   SetAuthToken(kValidAuthToken);
 }
 
 MockConnectionManager::~MockConnectionManager() {
   EXPECT_TRUE(update_queue_.empty()) << "Unfetched updates.";
 }
 
 void MockConnectionManager::SetCommitTimeRename(const string& prepend) {
   commit_time_rename_prepended_string_ = prepend;
 }
 
 void MockConnectionManager::SetMidCommitCallback(
     const base::Closure& callback) {
   mid_commit_callback_ = callback;
 }
 
 void MockConnectionManager::SetMidCommitObserver(
     MockConnectionManager::MidCommitObserver* observer) {
     mid_commit_observer_ = observer;
 }
 
 bool MockConnectionManager::PostBufferToPath(PostBufferParams* params,
-    const string& path,
-    const string& auth_token,
-    ScopedServerStatusWatcher* watcher) {
+                                             const string& path,
+                                             const string& auth_token) {
   ClientToServerMessage post;
   CHECK(post.ParseFromString(params->buffer_in));
   CHECK(post.has_protocol_version());
   CHECK(post.has_api_key());
   CHECK(post.has_bag_of_chips());
 
   requests_.push_back(post);
   client_stuck_ = post.sync_problem_detected();
   sync_pb::ClientToServerResponse response;
   response.Clear();
@@ skipping 72 matching lines @@
       sync_pb::ClientToServerResponse_Error* response_error =
           response.mutable_error();
       response_error->set_error_type(SyncEnums::PARTIAL_FAILURE);
       for (ModelTypeSet::Iterator it = throttled_type_.First(); it.Good();
            it.Inc()) {
         response_error->add_error_data_type_ids(
             GetSpecificsFieldNumberFromModelType(it.Get()));
       }
       partialThrottling_ = false;
     }
-
-    if (fail_with_auth_invalid_)
-      response.set_error_code(SyncEnums::AUTH_INVALID);
   }
 
   response.SerializeToString(&params->buffer_out);
   if (post.message_contents() == ClientToServerMessage::COMMIT &&
       !mid_commit_callback_.is_null()) {
     mid_commit_callback_.Run();
     mid_commit_callback_.Reset();
   }
   if (mid_commit_observer_) {
     mid_commit_observer_->Observe();
@@ skipping 584 matching lines @@
     server_status_ = HttpResponse::SERVER_CONNECTION_OK;
   }
 }
 
 void MockConnectionManager::SetServerStatus(
     HttpResponse::ServerConnectionCode server_status) {
   server_status_ = server_status;
 }
 
 }  // namespace syncer