sync: hook up ServerConnectionManager <> SyncerThread2 and tie up more loose ends

chrome/browser/sync/engine/net/server_connection_manager.cc

 // Copyright (c) 2010 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 "chrome/browser/sync/engine/net/server_connection_manager.h"
 
 #include <errno.h>
 
 #include <ostream>
 #include <string>
 #include <vector>
 
+#include "base/command_line.h"
 #include "build/build_config.h"
 #include "chrome/browser/sync/engine/net/url_translator.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/engine/syncproto.h"
 #include "chrome/browser/sync/protocol/sync.pb.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/net/http_return.h"
 #include "googleurl/src/gurl.h"
 
 namespace browser_sync {
 
 using std::ostream;
 using std::string;
 using std::vector;
 
 static const char kSyncServerSyncPath[] = "/command/";
@@ skipping 107 matching lines @@
     bool use_ssl,
     const string& user_agent)
     : sync_server_(server),
       sync_server_port_(port),
       user_agent_(user_agent),
       use_ssl_(use_ssl),
       proto_sync_path_(kSyncServerSyncPath),
       get_time_path_(kSyncServerGetTimePath),
       error_count_(0),
       channel_(new Channel(shutdown_event)),
+      listeners_(new ObserverListThreadSafe<ServerConnectionEventListener>()),
       server_status_(HttpResponse::NONE),
       server_reachable_(false),
       reset_count_(0),
       terminate_all_io_(false) {
 }
 
 ServerConnectionManager::~ServerConnectionManager() {
   delete channel_;
 }
 
 void ServerConnectionManager::NotifyStatusChanged() {
-  ServerConnectionEvent event = { ServerConnectionEvent::STATUS_CHANGED,
-                                  server_status_,
-                                  server_reachable_ };
-  channel_->NotifyListeners(event);
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kNewSyncerThread)) {
+    listeners_->Notify(&ServerConnectionEventListener::OnServerConnectionEvent,
+        ServerConnectionEvent2(server_status_, server_reachable_));
+  }  else {
+    ServerConnectionEvent event = { ServerConnectionEvent::STATUS_CHANGED,
+                                    server_status_,
+                                    server_reachable_ };
+    channel_->NotifyListeners(event);
+  }
 }
 
 bool ServerConnectionManager::PostBufferWithCachedAuth(
     const PostBufferParams* params, ScopedServerStatusWatcher* watcher) {
   string path =
       MakeSyncServerPath(proto_sync_path(), MakeSyncQueryString(client_id_));
   return PostBufferToPath(params, path, auth_token(), watcher);
 }
 
 bool ServerConnectionManager::PostBufferToPath(const PostBufferParams* params,
@@ skipping 150 matching lines @@
   // For unit tests.
   if (server_url.empty())
     return std::string();
   // We just want the hostname, so we don't need to switch on use_ssl.
   server_url = "http://" + server_url;
   GURL gurl(server_url);
   DCHECK(gurl.is_valid()) << gurl;
   return gurl.host();
 }
 
+void ServerConnectionManager::AddListener(
+    ServerConnectionEventListener* listener) {
+  listeners_->AddObserver(listener);
+}
+
+void ServerConnectionManager::RemoveListener(
+    ServerConnectionEventListener* listener) {
+  listeners_->RemoveObserver(listener);
+}
+
 ServerConnectionManager::Post* ServerConnectionManager::MakePost() {
   return NULL;  // For testing.
 }
 
 bool FillMessageWithShareDetails(sync_pb::ClientToServerMessage* csm,
                                  syncable::DirectoryManager* manager,
                                  const std::string& share) {
   syncable::ScopedDirLookup dir(manager, share);
   if (!dir.good()) {
     VLOG(1) << "Dir lookup failed";
     return false;
   }
   string birthday = dir->store_birthday();
   if (!birthday.empty())
     csm->set_store_birthday(birthday);
   csm->set_share(share);
   return true;
 }
 
 std::ostream& operator << (std::ostream& s, const struct HttpResponse& hr) {
   s << " Response Code (bogus on error): " << hr.response_code;
   s << " Content-Length (bogus on error): " << hr.content_length;
   s << " Server Status: " << hr.server_status;
   return s;
 }
 
 }  // namespace browser_sync