Sync: Remove pthreads from auth_watcher.

chrome/test/sync/engine/mock_server_connection.cc

 // Copyright (c) 2009 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/test/sync/engine/mock_server_connection.h"
 
 #include "chrome/browser/sync/engine/syncer_proto_util.h"
 #include "chrome/browser/sync/util/character_set_converters.h"
@@ skipping 52 matching lines @@
 }
 
 void MockConnectionManager::SetMidCommitObserver(
     MockConnectionManager::MidCommitObserver* observer) {
     mid_commit_observer_ = observer;
 }
 
 bool MockConnectionManager::PostBufferToPath(const PostBufferParams* params,
                                              const string& path,
                                              const string& auth_token) {
-
-  ScopedDirLookup directory(directory_manager_, directory_name_);
-  CHECK(directory.good());
-
   ClientToServerMessage post;
   CHECK(post.ParseFromString(params->buffer_in));
   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.
-  {
+  if (post.message_contents() != ClientToServerMessage::AUTHENTICATE) {
+    CHECK(directory.good());
     WriteTransaction wt(directory, syncable::UNITTEST, __FILE__, __LINE__);
   }
+
   if (fail_next_postbuffer_) {
     fail_next_postbuffer_ = false;
     return false;
   }
   // Default to an ok connection.
   params->response->server_status = HttpResponse::SERVER_CONNECTION_OK;
   response.set_store_birthday(store_birthday_);
   if (post.has_store_birthday() && post.store_birthday() != store_birthday_) {
     response.set_error_code(ClientToServerResponse::NOT_MY_BIRTHDAY);
     response.set_error_message("Merry Unbirthday!");
     response.SerializeToString(params->buffer_out);
     store_birthday_sent_ = true;
     return true;
   }
   bool result = true;
-  EXPECT_TRUE(!store_birthday_sent_ || post.has_store_birthday());
+  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 {
     EXPECT_TRUE(false) << "Unknown/unsupported ClientToServerMessage";
     return false;
   }
   if (client_command_.get()) {
     response.mutable_client_command()->CopyFrom(*client_command_.get());
   }
   response.SerializeToString(params->buffer_out);
   if (mid_commit_callback_function_) {
     if (mid_commit_callback_function_(directory))
@@ skipping 122 matching lines @@
     ClientToServerResponse* response) {
   CHECK(csm->has_get_updates());
   ASSERT_EQ(csm->message_contents(), ClientToServerMessage::GET_UPDATES);
   const GetUpdatesMessage& gu = csm->get_updates();
   EXPECT_TRUE(gu.has_from_timestamp());
   // TODO(sync): filter results dependant on timestamp? or check limits?
   response->mutable_get_updates()->CopyFrom(updates_);
   ResetUpdates();
 }
 
+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(ClientToServerResponse::AUTH_INVALID);
+    return;
+  }
+
+  response->set_error_code(ClientToServerResponse::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 80 matching lines @@
 
 SyncEntity* MockConnectionManager::GetMutableLastUpdate() {
   DCHECK(updates_.entries_size() > 0);
   return updates_.mutable_entries()->Mutable(updates_.entries_size() - 1);
 }
 
 const CommitMessage& MockConnectionManager::last_sent_commit() const {
   DCHECK(!commit_messages_.empty());
   return *commit_messages_.back();
 }