Reduce the copying of string data between C++ and javascript in proxy_resolver_v8.cc.

net/proxy/single_threaded_proxy_resolver_unittest.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.
 
+#include "base/string_util.h"
 #include "base/waitable_event.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/single_threaded_proxy_resolver.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 33 matching lines @@
 
     // Return a success code which represents the request's order.
     return request_count_++;
   }
 
   virtual void CancelRequest(RequestHandle request) {
     NOTREACHED();
   }
 
   virtual int SetPacScript(const GURL& pac_url,
-                           const std::string& bytes,
+                           const string16& text,
                            CompletionCallback* callback) {
     CheckIsOnWorkerThread();
-    last_pac_bytes_ = bytes;
+    last_pac_script_ = text;
     return OK;
   }
 
   virtual void PurgeMemory() {
     CheckIsOnWorkerThread();
     ++purge_count_;
   }
 
   int purge_count() const { return purge_count_; }
 
-  const std::string& last_pac_bytes() const { return last_pac_bytes_; }
+  const string16& last_pac_script() const { return last_pac_script_; }
 
   void SetResolveLatency(int latency_ms) {
     resolve_latency_ms_ = latency_ms;
   }
 
  private:
   void CheckIsOnWorkerThread() {
     // We should be running on the worker thread -- while we don't know the
     // message loop of SingleThreadedProxyResolver's worker thread, we do
     // know that it is going to be distinct from the loop running the
     // test, so at least make sure it isn't the main loop.
     EXPECT_NE(MessageLoop::current(), wrong_loop_);
   }
 
   MessageLoop* wrong_loop_;
   int request_count_;
   int purge_count_;
-  std::string last_pac_bytes_;
+  string16 last_pac_script_;
   int resolve_latency_ms_;
 };
 
 
 // A mock synchronous ProxyResolver which can be set to block upon reaching
 // GetProxyForURL().
 // TODO(eroman): WaitUntilBlocked() *must* be called before calling Unblock(),
 //               otherwise there will be a race on |should_block_| since it is
 //               read without any synchronization.
 class BlockableProxyResolver : public MockProxyResolver {
@@ skipping 43 matching lines @@
   MockProxyResolver* mock = new MockProxyResolver;
   SingleThreadedProxyResolver resolver(mock);
 
   int rv;
 
   EXPECT_TRUE(resolver.expects_pac_bytes());
 
   // Call SetPacScriptByData() -- verify that it reaches the synchronous
   // resolver.
   TestCompletionCallback set_script_callback;
-  rv = resolver.SetPacScriptByData("pac script bytes", &set_script_callback);
+  rv = resolver.SetPacScriptByData(ASCIIToUTF16("pac script bytes"),
+                                   &set_script_callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, set_script_callback.WaitForResult());
-  EXPECT_EQ("pac script bytes", mock->last_pac_bytes());
+  EXPECT_EQ(ASCIIToUTF16("pac script bytes"), mock->last_pac_script());
 
   // Start request 0.
   TestCompletionCallback callback0;
   CapturingBoundNetLog log0(CapturingNetLog::kUnbounded);
   ProxyInfo results0;
   rv = resolver.GetProxyForURL(
       GURL("http://request0"), &results0, &callback0, NULL, log0.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Wait for request 0 to finish.
@@ skipping 41 matching lines @@
   EXPECT_EQ("PROXY request3:80", results3.ToPacString());
 
   // Ensure that PurgeMemory() reaches the wrapped resolver and happens on the
   // right thread.
   EXPECT_EQ(0, mock->purge_count());
   resolver.PurgeMemory();
   // There is no way to get a callback directly when PurgeMemory() completes, so
   // we queue up a dummy request after the PurgeMemory() call and wait until it
   // finishes to ensure PurgeMemory() has had a chance to run.
   TestCompletionCallback dummy_callback;
-  rv = resolver.SetPacScriptByData("dummy", &dummy_callback);
+  rv = resolver.SetPacScriptByData(ASCIIToUTF16("dummy"), &dummy_callback);
   EXPECT_EQ(OK, dummy_callback.WaitForResult());
   EXPECT_EQ(1, mock->purge_count());
 }
 
 // Tests that the NetLog is updated to include the time the request was waiting
 // to be scheduled to a thread.
 TEST(SingleThreadedProxyResolverTest, UpdatesNetLogWithThreadWait) {
   BlockableProxyResolver* mock = new BlockableProxyResolver;
   SingleThreadedProxyResolver resolver(mock);
 
@@ skipping 200 matching lines @@
   TestCompletionCallback callback0;
   ProxyInfo results0;
   rv = resolver.GetProxyForURL(
       GURL("http://request0"), &results0, &callback0, &request0, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Wait until requests 0 reaches the worker thread.
   mock->WaitUntilBlocked();
 
   TestCompletionCallback set_pac_script_callback;
-  rv = resolver.SetPacScriptByData("data", &set_pac_script_callback);
+  rv = resolver.SetPacScriptByData(ASCIIToUTF16("data"),
+                                   &set_pac_script_callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Cancel the SetPacScriptByData request (it can't have finished yet,
   // since the single-thread is currently blocked).
   resolver.CancelSetPacScript();
 
   // Start 1 more request.
 
   TestCompletionCallback callback1;
   ProxyInfo results1;
@@ skipping 13 matching lines @@
   rv = callback1.WaitForResult();
   EXPECT_EQ(1, rv);
   EXPECT_EQ("PROXY request1:80", results1.ToPacString());
 
   // The SetPacScript callback should never have been completed.
   EXPECT_FALSE(set_pac_script_callback.have_result());
 }
 
 }  // namespace
 }  // namespace net