Trim code from sync's ServerConnectionManager

chrome/browser/sync/test/engine/mock_connection_manager.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.
 //
 // Mock ServerConnectionManager class for use in client regression tests.
 
 #include "chrome/browser/sync/test/engine/mock_connection_manager.h"
 
 #include <map>
 
@@ skipping 20 matching lines @@
 using sync_pb::GetUpdatesMessage;
 using sync_pb::SyncEnums;
 using sync_pb::SyncEntity;
 using syncable::DirectoryManager;
 using syncable::FIRST_REAL_MODEL_TYPE;
 using syncable::MODEL_TYPE_COUNT;
 using syncable::ModelType;
 using syncable::ScopedDirLookup;
 using syncable::WriteTransaction;
 
+static char kValidAuthToken[] = "AuthToken";
+
 MockConnectionManager::MockConnectionManager(DirectoryManager* dirmgr,
                                              const string& name)
     : ServerConnectionManager("unused", 0, false, "version"),
+      server_reachable_(true),
       conflict_all_commits_(false),
       conflict_n_commits_(0),
       next_new_id_(10000),
       store_birthday_("Store BDay!"),
       store_birthday_sent_(false),
       client_stuck_(false),
       commit_time_rename_prepended_string_(""),
       fail_next_postbuffer_(false),
       directory_manager_(dirmgr),
       directory_name_(name),
       mid_commit_observer_(NULL),
       throttling_(false),
       fail_with_auth_invalid_(false),
       fail_non_periodic_get_updates_(false),
       client_command_(NULL),
       next_position_in_parent_(2),
       use_legacy_bookmarks_protocol_(false),
       num_get_updates_requests_(0) {
-  server_reachable_ = true;
   SetNewTimestamp(0);
+  set_auth_token(kValidAuthToken);
 };
 
 MockConnectionManager::~MockConnectionManager() {
   EXPECT_TRUE(update_queue_.empty()) << "Unfetched updates.";
 }
 
 void MockConnectionManager::SetCommitTimeRename(string prepend) {
   commit_time_rename_prepended_string_ = prepend;
 }
 
@@ skipping 12 matching lines @@
     const string& auth_token,
     browser_sync::ScopedServerStatusWatcher* watcher) {
   ClientToServerMessage post;
   CHECK(post.ParseFromString(params->buffer_in));
   last_request_.CopyFrom(post);
   client_stuck_ = post.sync_problem_detected();
   ClientToServerResponse response;
   response.Clear();
 
   ScopedDirLookup directory(directory_manager_, directory_name_);
-  // For any non-AUTHENTICATE requests, a valid directory should be set up.
-  // If the Directory's locked when we do this, it's a problem as in normal
-  // use this function could take a while to return because it accesses the
-  // network. As we can't test this we do the next best thing and hang here
-  // when there's an issue.
+
+  // A valid directory should be set up.  If the Directory's locked when we do
+  // this, it's a problem as in normal use this function could take a while to
+  // return because it accesses the network. As we can't test this we do the
+  // next best thing and hang here when there's an issue.
   if (post.message_contents() != ClientToServerMessage::AUTHENTICATE) {
     CHECK(directory.good());
     WriteTransaction wt(FROM_HERE, syncable::UNITTEST, directory);
   }
 
+  if (auth_token.empty()) {
+    params->response.server_status = HttpResponse::SYNC_AUTH_ERROR;
+    return false;
+  }
+
+  if (auth_token != kValidAuthToken) {
+    // Simulate server-side auth failure.
+    params->response.server_status = HttpResponse::SYNC_AUTH_ERROR;
+    InvalidateAndClearAuthToken();
+  }
+
   if (fail_next_postbuffer_) {
+
     fail_next_postbuffer_ = false;
     return false;
   }
 
   if (!server_reachable_) {
     params->response.server_status = HttpResponse::CONNECTION_UNAVAILABLE;
     return false;
   }
 
   // Default to an ok connection.
@@ skipping 11 matching lines @@
   }
   bool result = true;
   EXPECT_TRUE(!store_birthday_sent_ || post.has_store_birthday() ||
               post.message_contents() == ClientToServerMessage::AUTHENTICATE);
   store_birthday_sent_ = true;
 
   if (post.message_contents() == ClientToServerMessage::COMMIT) {
     ProcessCommit(&post, &response);
   } else if (post.message_contents() == ClientToServerMessage::GET_UPDATES) {
     ProcessGetUpdates(&post, &response);
-  } else if (post.message_contents() == ClientToServerMessage::AUTHENTICATE) {
-    ProcessAuthenticate(&post, &response, auth_token);
   } else if (post.message_contents() == ClientToServerMessage::CLEAR_DATA) {
     ProcessClearData(&post, &response);
   } else {
     EXPECT_TRUE(false) << "Unknown/unsupported ClientToServerMessage";
     return false;
   }
   if (client_command_.get()) {
     response.mutable_client_command()->CopyFrom(*client_command_.get());
   }
 
@@ skipping 13 matching lines @@
       !mid_commit_callback_.is_null()) {
     mid_commit_callback_.Run();
   }
   if (mid_commit_observer_) {
     mid_commit_observer_->Observe();
   }
 
   return result;
 }
 
-bool MockConnectionManager::IsServerReachable() {
-  return true;
-}
-
-bool MockConnectionManager::IsUserAuthenticated() {
-  return true;
-}
-
 sync_pb::GetUpdatesResponse* MockConnectionManager::GetUpdateResponse() {
   if (update_queue_.empty()) {
     NextUpdateBatch();
   }
   return &update_queue_.back();
 }
 
 void MockConnectionManager::AddDefaultBookmarkData(sync_pb::SyncEntity* entity,
                                                    bool is_folder) {
   if (use_legacy_bookmarks_protocol_) {
@@ skipping 268 matching lines @@
 }
 
 void MockConnectionManager::ProcessClearData(ClientToServerMessage* csm,
   ClientToServerResponse* response) {
   CHECK(csm->has_clear_user_data());
   ASSERT_EQ(csm->message_contents(), ClientToServerMessage::CLEAR_DATA);
   response->clear_user_data();
   response->set_error_code(clear_user_data_response_errortype_);
 }
 
-void MockConnectionManager::ProcessAuthenticate(
-    ClientToServerMessage* csm,
-    ClientToServerResponse* response,
-    const std::string& auth_token) {
-  ASSERT_EQ(csm->message_contents(), ClientToServerMessage::AUTHENTICATE);
-  EXPECT_FALSE(auth_token.empty());
-
-  if (auth_token != valid_auth_token_) {
-    response->set_error_code(SyncEnums::AUTH_INVALID);
-    return;
-  }
-
-  response->set_error_code(SyncEnums::SUCCESS);
-  response->mutable_authenticate()->CopyFrom(auth_response_);
-  auth_response_.Clear();
-}
-
-void MockConnectionManager::SetAuthenticationResponseInfo(
-    const std::string& valid_auth_token,
-    const std::string& user_display_name,
-    const std::string& user_display_email,
-    const std::string& user_obfuscated_id) {
-  valid_auth_token_ = valid_auth_token;
-  sync_pb::UserIdentification* user = auth_response_.mutable_user();
-  user->set_display_name(user_display_name);
-  user->set_email(user_display_email);
-  user->set_obfuscated_id(user_obfuscated_id);
-}
-
 bool MockConnectionManager::ShouldConflictThisCommit() {
   bool conflict = false;
   if (conflict_all_commits_) {
     conflict = true;
   } else if (conflict_n_commits_ > 0) {
     conflict = true;
     --conflict_n_commits_;
   }
   return conflict;
 }
@@ skipping 132 matching lines @@
   int data_type_id = syncable::GetExtensionFieldNumberFromModelType(value);
   for (int i = 0; i < filter.size(); ++i) {
     if (filter.Get(i).data_type_id() == data_type_id) {
       return &(filter.Get(i));
     }
   }
   return NULL;
 }
 
 void MockConnectionManager::SetServerReachable() {
-  server_status_ = HttpResponse::SERVER_CONNECTION_OK;
   server_reachable_ = true;
-
-  FOR_EACH_OBSERVER(ServerConnectionEventListener, listeners_,
-     OnServerConnectionEvent(
-         ServerConnectionEvent(server_status_, server_reachable_)));
 }
 
 void MockConnectionManager::SetServerNotReachable() {
-  server_status_ = HttpResponse::CONNECTION_UNAVAILABLE;
   server_reachable_ = false;
+}
 
-  FOR_EACH_OBSERVER(ServerConnectionEventListener, listeners_,
-     OnServerConnectionEvent(
-         ServerConnectionEvent(server_status_, server_reachable_)));
+void MockConnectionManager::UpdateConnectionStatus() {
+  if (!server_reachable_) {
+    server_status_ = HttpResponse::CONNECTION_UNAVAILABLE;
+  } else {
+    server_status_ = HttpResponse::SERVER_CONNECTION_OK;
+  }
 }