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

net/proxy/mock_proxy_resolver.h

 // 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.
 
 #ifndef NET_PROXY_MOCK_PROXY_RESOLVER_H_
 #define NET_PROXY_MOCK_PROXY_RESOLVER_H_
 
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 43 matching lines @@
     const GURL url_;
     ProxyInfo* results_;
     CompletionCallback* callback_;
     MessageLoop* origin_loop_;
   };
 
   class SetPacScriptRequest {
    public:
     SetPacScriptRequest(MockAsyncProxyResolverBase* resolver,
                         const GURL& pac_url,
-                        const std::string& pac_bytes,
+                        const string16& pac_script,
                         CompletionCallback* callback)
         : resolver_(resolver),
           pac_url_(pac_url),
-          pac_bytes_(pac_bytes),
+          pac_script_(pac_script),
           callback_(callback),
           origin_loop_(MessageLoop::current()) {
     }
 
     const GURL& pac_url() const { return pac_url_; }
-    const std::string& pac_bytes() const { return pac_bytes_; }
+    const string16& pac_script() const { return pac_script_; }
 
     void CompleteNow(int rv) {
        CompletionCallback* callback = callback_;
 
       // Will delete |this|.
       resolver_->RemovePendingSetPacScriptRequest(this);
 
       callback->Run(rv);
     }
 
    private:
     MockAsyncProxyResolverBase* resolver_;
     const GURL pac_url_;
-    const std::string pac_bytes_;
+    const string16 pac_script_;
     CompletionCallback* callback_;
     MessageLoop* origin_loop_;
   };
 
   typedef std::vector<scoped_refptr<Request> > RequestsList;
 
   // ProxyResolver implementation:
   virtual int GetProxyForURL(const GURL& url,
                              ProxyInfo* results,
                              CompletionCallback* callback,
                              RequestHandle* request_handle,
                              const BoundNetLog& /*net_log*/) {
     scoped_refptr<Request> request = new Request(this, url, results, callback);
     pending_requests_.push_back(request);
 
     if (request_handle)
       *request_handle = reinterpret_cast<RequestHandle>(request.get());
 
     // Test code completes the request by calling request->CompleteNow().
     return ERR_IO_PENDING;
   }
 
   virtual void CancelRequest(RequestHandle request_handle) {
     scoped_refptr<Request> request = reinterpret_cast<Request*>(request_handle);
     cancelled_requests_.push_back(request);
     RemovePendingRequest(request);
   }
 
   virtual int SetPacScript(const GURL& pac_url,
-                           const std::string& pac_bytes,
+                           const string16& pac_script,
                            CompletionCallback* callback) {
     DCHECK(!pending_set_pac_script_request_.get());
     pending_set_pac_script_request_.reset(
-        new SetPacScriptRequest(this, pac_url, pac_bytes, callback));
+        new SetPacScriptRequest(this, pac_url, pac_script, callback));
     // Finished when user calls SetPacScriptRequest::CompleteNow().
     return ERR_IO_PENDING;
   }
 
   virtual void CancelSetPacScript() {
     // Do nothing (caller was responsible for completing the request).
   }
 
   const RequestsList& pending_requests() const {
     return pending_requests_;
@@ skipping 37 matching lines @@
 
 class MockAsyncProxyResolverExpectsBytes : public MockAsyncProxyResolverBase {
  public:
   MockAsyncProxyResolverExpectsBytes()
       : MockAsyncProxyResolverBase(true /*expects_pac_bytes*/) {}
 };
 
 }  // namespace net
 
 #endif  // NET_PROXY_MOCK_PROXY_RESOLVER_H_