Simple offline startup integration test.

chrome/test/live_sync/live_sync_test.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/test/live_sync/live_sync_test.h"
 
 #include <vector>
 
 #include "base/command_line.h"
+#include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
+#include "base/task.h"
+#include "base/waitable_event.h"
+#include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/profile_manager.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/net/url_fetcher.h"
+#include "chrome/common/net/url_request_context_getter.h"
+#include "chrome/test/testing_browser_process.h"
+#include "googleurl/src/gurl.h"
+#include "net/base/escape.h"
+#include "net/proxy/proxy_config.h"
+#include "net/proxy/proxy_config_service_fixed.h"
+#include "net/proxy/proxy_service.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_status.h"
 
 namespace switches {
 const std::string kPasswordFileForTest = "password-file-for-test";
 const std::string kSyncUserForTest = "sync-user-for-test";
 const std::string kSyncPasswordForTest = "sync-password-for-test";
 }
 
+class ConfigureURLFectcherDelegate : public URLFetcher::Delegate {
+ public:
+  ConfigureURLFectcherDelegate() : success_(false) {}
+
+  virtual void OnURLFetchComplete(const URLFetcher* source,
+                                  const GURL& url,
+                                  const URLRequestStatus& status,
+                                  int response_code,
+                                  const ResponseCookies& cookies,
+                                  const std::string& data) {
+    if (status.status() == URLRequestStatus::SUCCESS && response_code == 200)
+      success_ = true;
+    MessageLoop::current()->Quit();
+  }
+
+  bool success() const { return success_; }
+
+ private:
+  bool success_;
+};
+
+class SetProxyConfigTask : public Task {
+ public:
+  SetProxyConfigTask(base::WaitableEvent* done,
+                     URLRequestContextGetter* url_request_context_getter,
+                     const net::ProxyConfig& proxy_config)
+      : done_(done),
+        url_request_context_getter_(url_request_context_getter),
+        proxy_config_(proxy_config) {
+  }
+
+  void Run() {
+    net::ProxyService* proxy_service =
+        url_request_context_getter_->GetURLRequestContext()->proxy_service();
+    proxy_service->ResetConfigService(
+        new net::ProxyConfigServiceFixed(proxy_config_));
+    done_->Signal();
+  }
+
+ private:
+  base::WaitableEvent* done_;
+  URLRequestContextGetter* url_request_context_getter_;
+  net::ProxyConfig proxy_config_;
+};
+
 void LiveSyncTest::SetUp() {
   // At this point, the browser hasn't been launched, and no services are
   // available.  But we can verify our command line parameters and fail
   // early.
   CommandLine* cl = CommandLine::ForCurrentProcess();
   if (cl->HasSwitch(switches::kPasswordFileForTest)) {
     // Read GAIA credentials from a local password file if specified via the
     // "--password-file-for-test" command line switch. Note: The password file
     // must be a plain text file with exactly two lines -- the username on the
     // first line and the password on the second line.
@@ skipping 158 matching lines @@
   CommandLine* cl = CommandLine::ForCurrentProcess();
   cl->AppendSwitchASCII(switches::kSyncServiceURL,
       StringPrintf("http://%s:%d/chromiumsync", server_.kHostName,
                    server_.kOKHTTPSPort));
 }
 
 void LiveSyncTest::TearDownLocalTestServer() {
   bool success = server_.Stop();
   ASSERT_TRUE(success);
 }
+
+
+void LiveSyncTest::EnableNetwork(Profile* profile) {
+  SetProxyConfig(profile->GetRequestContext(),
+                 net::ProxyConfig::CreateDirect());
+}
+
+void LiveSyncTest::DisableNetwork(Profile* profile) {
+  // Set the current proxy configuration to a nonexistent proxy to
+  // effectively disable networking.
+  net::ProxyConfig config;
+  config.proxy_rules().ParseFromString("http=127.0.0.1:0");
+  SetProxyConfig(profile->GetRequestContext(), config);
+}
+
+bool LiveSyncTest::EnsureSyncServerConfiguration() {
+  const CommandLine* cl = CommandLine::ForCurrentProcess();
+  if (!cl->HasSwitch(switches::kSyncServiceURL))
+    return true;
+
+  return ConfigureSyncServer("user_email", username_);
+}
+
+void LiveSyncTest::SetProxyConfig(URLRequestContextGetter* context_getter,
+                                  const net::ProxyConfig& proxy_config) {
+  base::WaitableEvent done(false, false);
+  ChromeThread::PostTask(
+      ChromeThread::IO,
+      FROM_HERE,
+      new SetProxyConfigTask(&done,
+                             context_getter,
+                             proxy_config));
+  done.Wait();
+}
+
+bool LiveSyncTest::ConfigureSyncServer(const std::string& name,
+                                       const std::string& value) {
+  std::string url = StringPrintf("http://%s:%d/chromiumsync/configure",
+                                 server_.kHostName,
+                                 server_.kOKHTTPSPort);
+  std::string data = EscapePath(name) + "=" + EscapePath(value);
+  ConfigureURLFectcherDelegate delegate;
+  scoped_ptr<URLFetcher> fetcher(
+      URLFetcher::Create(0, GURL(url), URLFetcher::POST, &delegate));
+  fetcher->set_request_context(Profile::GetDefaultRequestContext());
+  fetcher->set_upload_data("application/x-www-form-urlencoded", data);
+  fetcher->Start();
+  MessageLoop::current()->Run();
+  return delegate.success();
+}