Update SyncManager::Init to use a GURL for the sync server URL.

sync/tools/sync_client.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.
 
 #include <cstddef>
 #include <cstdio>
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
@@ skipping 28 matching lines @@
 #include "sync/internal_api/public/sync_manager.h"
 #include "sync/internal_api/public/sync_manager_factory.h"
 #include "sync/internal_api/public/util/report_unrecoverable_error_function.h"
 #include "sync/internal_api/public/util/unrecoverable_error_handler.h"
 #include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/js/js_event_details.h"
 #include "sync/js/js_event_handler.h"
 #include "sync/test/fake_encryptor.h"
 #include "sync/tools/invalidation_helper.h"
 #include "sync/tools/null_invalidation_state_tracker.h"
+#include "url/gurl.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 
 // This is a simple utility that initializes a sync client and
 // prints out any events.
 
 // TODO(akalin): Refactor to combine shared code with
 // sync_listen_notifications.
 namespace syncer {
 namespace {
 
 const char kEmailSwitch[] = "email";
 const char kTokenSwitch[] = "token";
 const char kXmppHostPortSwitch[] = "xmpp-host-port";
 const char kXmppTrySslTcpFirstSwitch[] = "xmpp-try-ssltcp-first";
 const char kXmppAllowInsecureConnectionSwitch[] =
     "xmpp-allow-insecure-connection";
+const char kSyncServiceURL[] = "https://clients4.google.com/chrome-sync/dev";
 
 // Needed to use a real host resolver.
 class MyTestURLRequestContext : public net::TestURLRequestContext {
  public:
   MyTestURLRequestContext() : TestURLRequestContext(true) {
     context_storage_.set_host_resolver(
         net::HostResolver::CreateDefaultResolver(NULL));
     context_storage_.set_transport_security_state(
         new net::TransportSecurityState());
     Init();
@@ skipping 319 matching lines @@
   scoped_refptr<PassiveModelWorker> passive_model_safe_worker =
       new PassiveModelWorker(&sync_loop, NULL);
   std::vector<scoped_refptr<ModelSafeWorker> > workers;
   workers.push_back(passive_model_safe_worker);
 
   // Set up sync manager.
   SyncManagerFactory sync_manager_factory(SyncManagerFactory::NORMAL);
   scoped_ptr<SyncManager> sync_manager =
       sync_manager_factory.CreateSyncManager("sync_client manager");
   LoggingJsEventHandler js_event_handler;
-  const char kSyncServerAndPath[] = "clients4.google.com/chrome-sync/dev";
-  int kSyncServerPort = 443;
-  bool kUseSsl = true;
   // Used only by InitialProcessMetadata(), so it's okay to leave this as NULL.
   const scoped_refptr<base::TaskRunner> blocking_task_runner = NULL;
   const char kUserAgent[] = "sync_client";
   // TODO(akalin): Replace this with just the context getter once
   // HttpPostProviderFactory is removed.
   CancelationSignal factory_cancelation_signal;
   scoped_ptr<HttpPostProviderFactory> post_factory(
       new HttpBridgeFactory(context_getter.get(),
                             base::Bind(&StubNetworkTimeUpdateCallback),
                             &factory_cancelation_signal));
   post_factory->Init(kUserAgent);
   // Used only when committing bookmarks, so it's okay to leave this
   // as NULL.
   ExtensionsActivity* extensions_activity = NULL;
   LoggingChangeDelegate change_delegate;
   const char kRestoredKeyForBootstrapping[] = "";
   const char kRestoredKeystoreKeyForBootstrapping[] = "";
   NullEncryptor null_encryptor;
   InternalComponentsFactoryImpl::Switches factory_switches = {
       InternalComponentsFactory::ENCRYPTION_KEYSTORE,
       InternalComponentsFactory::BACKOFF_NORMAL
   };
   CancelationSignal scm_cancelation_signal;
 
   sync_manager->Init(database_dir.path(),
-                    WeakHandle<JsEventHandler>(
-                        js_event_handler.AsWeakPtr()),
-                    kSyncServerAndPath,
-                    kSyncServerPort,
-                    kUseSsl,
-                    post_factory.Pass(),
-                    workers,
-                    extensions_activity,
-                    &change_delegate,
-                    credentials,
-                    invalidator_id,
-                    kRestoredKeyForBootstrapping,
-                    kRestoredKeystoreKeyForBootstrapping,
-                    new InternalComponentsFactoryImpl(factory_switches),
-                    &null_encryptor,
-                    scoped_ptr<UnrecoverableErrorHandler>(
-                        new LoggingUnrecoverableErrorHandler).Pass(),
-                    &LogUnrecoverableErrorContext,
-                    &scm_cancelation_signal);
+                     WeakHandle<JsEventHandler>(js_event_handler.AsWeakPtr()),
+                     GURL(kSyncServiceURL),
+                     post_factory.Pass(),
+                     workers,
+                     extensions_activity,
+                     &change_delegate,
+                     credentials,
+                     invalidator_id,
+                     kRestoredKeyForBootstrapping,
+                     kRestoredKeystoreKeyForBootstrapping,
+                     new InternalComponentsFactoryImpl(factory_switches),
+                     &null_encryptor,
+                     scoped_ptr<UnrecoverableErrorHandler>(
+                         new LoggingUnrecoverableErrorHandler).Pass(),
+                     &LogUnrecoverableErrorContext,
+                     &scm_cancelation_signal);
   // TODO(akalin): Avoid passing in model parameters multiple times by
   // organizing handling of model types.
   invalidator->UpdateCredentials(credentials.email, credentials.sync_token);
   scoped_ptr<InvalidatorShim> shim(new InvalidatorShim(sync_manager.get()));
   invalidator->RegisterHandler(shim.get());
   invalidator->UpdateRegisteredIds(
       shim.get(), ModelTypeSetToObjectIdSet(model_types));
   sync_manager->StartSyncingNormally(routing_info);
 
   sync_loop.Run();
 
   io_thread.Stop();
   return 0;
 }
 
 }  // namespace
 }  // namespace syncer
 
 int main(int argc, char* argv[]) {
   return syncer::SyncClientMain(argc, argv);
 }