Adding the ability to alter Chrome's proxy settings via the automation interf...

net/proxy/proxy_service_unittest.cc

 // Copyright (c) 2006-2008 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 "base/compiler_specific.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/proxy/proxy_resolver.h"
 #include "net/proxy/proxy_script_fetcher.h"
@@ skipping 120 matching lines @@
 
   // Start the request. Return once ProxyService::GetProxyForURL() or
   // ProxyService::ReconsiderProxyAfterError() returns.
   void StartRequest(const GURL& url, RequestMethod method) {
     DCHECK(MessageLoop::current() != io_message_loop_);
     io_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
         this, &ResultFuture::DoStartRequest, url, method));
     started_.Wait();
   }
 
+  void StartResetConfigService(
+      net::ProxyConfigService* new_proxy_config_service) {
+    DCHECK(MessageLoop::current() != io_message_loop_);
+    io_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+        this, &ResultFuture::DoResetConfigService, new_proxy_config_service));
+    started_.Wait();
+  }
+
   // Called on |io_message_loop_|.
   void DoStartRequest(const GURL& url, RequestMethod method) {
     DCHECK(MessageLoop::current() == io_message_loop_);
     int rv = (service_->*method)(url, &proxy_info_, &callback_, &request_);
     if (rv != net::ERR_IO_PENDING) {
       // Completed synchronously.
       OnCompletion(rv);
     }
     started_.Signal();
   }
 
   // Called on |io_message_loop_|.
+  void DoResetConfigService(net::ProxyConfigService* new_proxy_config_service) {
+    DCHECK(MessageLoop::current() == io_message_loop_);
+    service_->ResetConfigService(new_proxy_config_service);
+    started_.Signal();
+    OnCompletion(0);
+  }
+
+  // Called on |io_message_loop_|.
   void DoCancel() {
     DCHECK(MessageLoop::current() == io_message_loop_);
     if (!did_complete_)
       service_->CancelPacRequest(request_);
     cancelled_.Signal();
   }
 
   // Called on |io_message_loop_|.
   void OnCompletion(int result) {
     DCHECK(MessageLoop::current() == io_message_loop_);
@@ skipping 60 matching lines @@
 
   // Same as above, but for "ReconsiderProxyAfterError()".
   void ReconsiderProxyAfterError(scoped_refptr<ResultFuture>* result,
                                  const GURL& url,
                                  const net::ProxyInfo& proxy_info) {
     *result = new ResultFuture(io_thread_.message_loop(),
                                io_thread_state_->service);
     (*result)->StartReconsider(url, proxy_info);
   }
 
+  void ResetConfigService(scoped_refptr<ResultFuture>* result,
+                          net::ProxyConfigService* new_proxy_config_service) {
+    *result = new ResultFuture(io_thread_.message_loop(),
+                               io_thread_state_->service);
+    (*result)->StartResetConfigService(new_proxy_config_service);
+  }
+
   void SetProxyScriptFetcher(net::ProxyScriptFetcher* proxy_script_fetcher) {
     io_thread_.message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
         io_thread_state_.get(), &IOThreadState::DoSetProxyScriptFetcher,
         proxy_script_fetcher));
     io_thread_state_->event.Wait();
   }
 
  private:
   // Class that encapsulates the state living on IO thread. It needs to be
   // ref-counted for posting tasks.
@@ skipping 42 matching lines @@
     return result->GetResultCode();
   }
 
   int ReconsiderProxyAfterError(const GURL& url, net::ProxyInfo* proxy_info) {
     scoped_refptr<ResultFuture> result;
     service_.ReconsiderProxyAfterError(&result, url, *proxy_info);
     *proxy_info = result->GetProxyInfo();
     return result->GetResultCode();
   }
 
+  int ResetConfigService(net::ProxyConfigService* new_proxy_config_service) {
+    scoped_refptr<ResultFuture> result;
+    service_.ResetConfigService(&result, new_proxy_config_service);
+    return result->GetResultCode();
+  }
+
  private:
   ProxyServiceWithFutures service_;
 };
 
 // A ProxyResolver which can be set to block upon reaching GetProxyForURL.
 class BlockableProxyResolver : public net::ProxyResolver {
  public:
   BlockableProxyResolver() : net::ProxyResolver(true),
                              should_block_(false),
                              unblocked_(true, true),
@@ skipping 784 matching lines @@
   result3->WaitUntilCompleted();
 
   EXPECT_FALSE(result1->IsCompleted());  // Cancelled.
   EXPECT_FALSE(result2->IsCompleted());  // Cancelled.
 
   EXPECT_TRUE(result3->IsCompleted());
   EXPECT_EQ(net::OK, result3->GetResultCode());
   EXPECT_EQ("pac-v1.request3:80",
             result3->GetProxyInfo().proxy_server().ToURI());
 }
+
+TEST(ProxyServiceTest, ResetProxyConfigService) {
+  net::ProxyConfig config1;
+  config1.proxy_rules.ParseFromString("foopy1:8080");
+  config1.auto_detect = false;
+  scoped_ptr<SyncProxyService> service(
+      new SyncProxyService(new MockProxyConfigService(config1),
+                           new MockProxyResolverWithoutFetch));
+
+  net::ProxyInfo info;
+  service->ResolveProxy(GURL("http://request1"), &info);
+  EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
+
+  net::ProxyConfig config2;
+  config2.proxy_rules.ParseFromString("foopy2:8080");
+  config2.auto_detect = false;
+  int result = service->ResetConfigService(new MockProxyConfigService(config2));
+  DCHECK(result == 0);
+  service->ResolveProxy(GURL("http://request2"), &info);
+  EXPECT_EQ("foopy2:8080", info.proxy_server().ToURI());
+}