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

net/proxy/proxy_script_fetcher.cc

-// Copyright (c) 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.
+// 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 "net/proxy/proxy_script_fetcher.h"
 
 #include "base/compiler_specific.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 24 matching lines @@
     "application/x-ns-proxy-autoconfig",
     "application/x-javascript-config",
   };
   for (size_t i = 0; i < arraysize(kSupportedPacMimeTypes); ++i) {
     if (LowerCaseEqualsASCII(mime_type, kSupportedPacMimeTypes[i]))
       return true;
   }
   return false;
 }
 
-// Convert |bytes| (which is encoded by |charset|) in place to UTF8.
+// Converts |bytes| (which is encoded by |charset|) to UTF16, saving the resul
+// to |*utf16|.
 // If |charset| is empty, then we don't know what it was and guess.
-void ConvertResponseToUTF8(const std::string& charset, std::string* bytes) {
+void ConvertResponseToUTF16(const std::string& charset,
+                            const std::string& bytes,
+                            string16* utf16) {
   const char* codepage;
 
   if (charset.empty()) {
     // Assume ISO-8859-1 if no charset was specified.
     codepage = base::kCodepageLatin1;
   } else {
     // Otherwise trust the charset that was provided.
     codepage = charset.c_str();
   }
 
   // We will be generous in the conversion -- if any characters lie
   // outside of |charset| (i.e. invalid), then substitute them with
   // U+FFFD rather than failing.
-  std::wstring tmp_wide;
-  base::CodepageToWide(*bytes, codepage,
-                       base::OnStringConversionError::SUBSTITUTE,
-                       &tmp_wide);
-  // TODO(eroman): would be nice to have a CodepageToUTF8() function.
-  *bytes = WideToUTF8(tmp_wide);
+  base::CodepageToUTF16(bytes, codepage,
+                        base::OnStringConversionError::SUBSTITUTE,
+                        utf16);
 }
 
 }  // namespace
 
 class ProxyScriptFetcherImpl : public ProxyScriptFetcher,
                                public URLRequest::Delegate {
  public:
   // Creates a ProxyScriptFetcher that issues requests through
   // |url_request_context|. |url_request_context| must remain valid for the
   // lifetime of ProxyScriptFetcherImpl.
   explicit ProxyScriptFetcherImpl(URLRequestContext* url_request_context);
 
   virtual ~ProxyScriptFetcherImpl();
 
   // ProxyScriptFetcher methods:
 
-  virtual int Fetch(const GURL& url, std::string* bytes,
+  virtual int Fetch(const GURL& url, string16* text,
                     CompletionCallback* callback);
   virtual void Cancel();
   virtual URLRequestContext* GetRequestContext();
 
   // URLRequest::Delegate methods:
 
   virtual void OnAuthRequired(URLRequest* request,
                               AuthChallengeInfo* auth_info);
   virtual void OnSSLCertificateError(URLRequest* request, int cert_error,
                                      X509Certificate* cert);
   virtual void OnResponseStarted(URLRequest* request);
   virtual void OnReadCompleted(URLRequest* request, int num_bytes);
   virtual void OnResponseCompleted(URLRequest* request);
 
  private:
   // Read more bytes from the response.
   void ReadBody(URLRequest* request);
 
   // Called once the request has completed to notify the caller of
-  // |response_code_| and |response_bytes_|.
+  // |response_code_| and |response_text_|.
   void FetchCompleted();
 
   // Clear out the state for the current request.
   void ResetCurRequestState();
 
   // Callback for time-out task of request with id |id|.
   void OnTimeout(int id);
 
   // Factory for creating the time-out task. This takes care of revoking
   // outstanding tasks when |this| is deleted.
@@ skipping 16 matching lines @@
 
   // Unique ID for the current request.
   int cur_request_id_;
 
   // Callback to invoke on completion of the fetch.
   CompletionCallback* callback_;
 
   // Holds the error condition that was hit on the current request, or OK.
   int result_code_;
 
-  // Holds the bytes read so far. Will not exceed |max_response_bytes|. This
-  // buffer is owned by the owner of |callback|.
-  std::string* result_bytes_;
+  // Holds the bytes read so far. Will not exceed |max_response_bytes|.
+  std::string bytes_read_so_far_;
+
+  // This buffer is owned by the owner of |callback|, and will be filled with
+  // UTF16 response on completion.
+  string16* result_text_;
 };
 
 ProxyScriptFetcherImpl::ProxyScriptFetcherImpl(
     URLRequestContext* url_request_context)
     : ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       url_request_context_(url_request_context),
       buf_(new net::IOBuffer(kBufSize)),
       next_id_(0),
       cur_request_(NULL),
       cur_request_id_(0),
       callback_(NULL),
       result_code_(OK),
-      result_bytes_(NULL) {
+      result_text_(NULL) {
   DCHECK(url_request_context);
 }
 
 ProxyScriptFetcherImpl::~ProxyScriptFetcherImpl() {
   // The URLRequest's destructor will cancel the outstanding request, and
   // ensure that the delegate (this) is not called again.
 }
 
 int ProxyScriptFetcherImpl::Fetch(const GURL& url,
-                                  std::string* bytes,
+                                  string16* text,
                                   CompletionCallback* callback) {
   // It is invalid to call Fetch() while a request is already in progress.
   DCHECK(!cur_request_.get());
 
   DCHECK(callback);
-  DCHECK(bytes);
+  DCHECK(text);
 
   cur_request_.reset(new URLRequest(url, this));
   cur_request_->set_context(url_request_context_);
   cur_request_->set_method("GET");
 
   // Make sure that the PAC script is downloaded using a direct connection,
   // to avoid circular dependencies (fetching is a part of proxy resolution).
   // Also disable the use of the disk cache. The cache is disabled so that if
   // the user switches networks we don't potentially use the cached response
   // from old network when we should in fact be re-fetching on the new network.
   cur_request_->set_load_flags(LOAD_BYPASS_PROXY | LOAD_DISABLE_CACHE);
 
   // Save the caller's info for notification on completion.
   callback_ = callback;
-  result_bytes_ = bytes;
-  result_bytes_->clear();
+  result_text_ = text;
+
+  bytes_read_so_far_.clear();
 
   // Post a task to timeout this request if it takes too long.
   cur_request_id_ = ++next_id_;
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       task_factory_.NewRunnableMethod(&ProxyScriptFetcherImpl::OnTimeout,
                                       cur_request_id_),
       static_cast<int>(max_duration_ms));
 
   // Start the request.
   cur_request_->Start();
@@ skipping 61 matching lines @@
   }
 
   ReadBody(request);
 }
 
 void ProxyScriptFetcherImpl::OnReadCompleted(URLRequest* request,
                                              int num_bytes) {
   DCHECK(request == cur_request_.get());
   if (num_bytes > 0) {
     // Enforce maximum size bound.
-    if (num_bytes + result_bytes_->size() >
+    if (num_bytes + bytes_read_so_far_.size() >
         static_cast<size_t>(max_response_bytes)) {
       result_code_ = ERR_FILE_TOO_BIG;
       request->Cancel();
       return;
     }
-    result_bytes_->append(buf_->data(), num_bytes);
+    bytes_read_so_far_.append(buf_->data(), num_bytes);
     ReadBody(request);
   } else {  // Error while reading, or EOF
     OnResponseCompleted(request);
   }
 }
 
 void ProxyScriptFetcherImpl::OnResponseCompleted(URLRequest* request) {
   DCHECK(request == cur_request_.get());
 
   // Use |result_code_| as the request's error if we have already set it to
   // something specific.
   if (result_code_ == OK && !request->status().is_success())
     result_code_ = request->status().os_error();
 
   FetchCompleted();
 }
 
 void ProxyScriptFetcherImpl::ReadBody(URLRequest* request) {
   int num_bytes;
   if (request->Read(buf_, kBufSize, &num_bytes)) {
     OnReadCompleted(request, num_bytes);
   } else if (!request->status().is_io_pending()) {
     // Read failed synchronously.
     OnResponseCompleted(request);
   }
 }
 
 void ProxyScriptFetcherImpl::FetchCompleted() {
   if (result_code_ == OK) {
-    // The caller expects the response to be encoded as UTF8.
+    // The caller expects the response to be encoded as UTF16.
     std::string charset;
     cur_request_->GetCharset(&charset);
-    ConvertResponseToUTF8(charset, result_bytes_);
+    ConvertResponseToUTF16(charset, bytes_read_so_far_, result_text_);
   } else {
     // On error, the caller expects empty string for bytes.
-    result_bytes_->clear();
+    result_text_->clear();
   }
 
   int result_code = result_code_;
   CompletionCallback* callback = callback_;
 
   ResetCurRequestState();
 
   callback->Run(result_code);
 }
 
 void ProxyScriptFetcherImpl::ResetCurRequestState() {
   cur_request_.reset();
   cur_request_id_ = 0;
   callback_ = NULL;
   result_code_ = OK;
-  result_bytes_ = NULL;
+  result_text_ = NULL;
 }
 
 void ProxyScriptFetcherImpl::OnTimeout(int id) {
   // Timeout tasks may outlive the URLRequest they reference. Make sure it
   // is still applicable.
   if (cur_request_id_ != id)
     return;
 
   DCHECK(cur_request_.get());
   result_code_ = ERR_TIMED_OUT;
@@ skipping 15 matching lines @@
 }
 
 // static
 size_t ProxyScriptFetcher::SetSizeConstraintForUnittest(size_t size_bytes) {
   size_t prev = max_response_bytes;
   max_response_bytes = size_bytes;
   return prev;
 }
 
 }  // namespace net