Use chrome/base synchronization primitives and threads instead of...

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"
 #include "chrome/test/sync/engine/test_id_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using browser_sync::HttpResponse;
 using browser_sync::ServerConnectionManager;
 using browser_sync::SyncerProtoUtil;
 using browser_sync::TestIdFactory;
 using std::map;
 using std::string;
 using sync_pb::ClientToServerMessage;
 using sync_pb::ClientToServerResponse;
 using sync_pb::CommitMessage;
 using sync_pb::CommitResponse;
 using sync_pb::CommitResponse_EntryResponse;
 using sync_pb::GetUpdatesMessage;
 using sync_pb::SyncEntity;
 using syncable::DirectoryManager;
+using syncable::ScopedDirLookup;
 using syncable::WriteTransaction;
 
 MockConnectionManager::MockConnectionManager(DirectoryManager* dirmgr,
                                              PathString name)
     : ServerConnectionManager("unused", 0, false, "version", "id"),
       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_(dirmgr, name),
+      directory_manager_(dirmgr),
+      directory_name_(name),
       mid_commit_callback_function_(NULL),
+      mid_commit_observer_(NULL),
       client_command_(NULL),
       next_position_in_parent_(2) {
     server_reachable_ = true;
-    CHECK(directory_.good());
 };
 
 MockConnectionManager::~MockConnectionManager() {
   for (size_t i = 0; i < commit_messages_.size(); i++)
     delete commit_messages_[i];
 }
 
 void MockConnectionManager::SetCommitTimeRename(string prepend) {
   commit_time_rename_prepended_string_ = prepend;
 }
 
 void MockConnectionManager::SetMidCommitCallbackFunction(
     MockConnectionManager::TestCallbackFunction callback) {
   mid_commit_callback_function_ = callback;
 }
 
+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();
   // 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.
   {
-    WriteTransaction wt(directory_, syncable::UNITTEST, __FILE__, __LINE__);
+    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);
@@ skipping 11 matching lines @@
     ProcessGetUpdates(&post, &response);
   } 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_))
+    if (mid_commit_callback_function_(directory))
       mid_commit_callback_function_ = 0;
   }
+  if (mid_commit_observer_) {
+    mid_commit_observer_->Observe();
+  }
   return result;
 }
 
 bool MockConnectionManager::IsServerReachable() {
   return true;
 }
 
 bool MockConnectionManager::IsUserAuthenticated() {
   return true;
 }
@@ skipping 207 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();
 }