Avoid a string copy in URLRequestResourceBundleJob::GetData().

chrome/browser/extensions/chrome_url_request_util.cc

 // Copyright 2014 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/browser/extensions/chrome_url_request_util.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 41 matching lines @@
       : net::URLRequestSimpleJob(request, network_delegate),
         filename_(filename),
         resource_id_(resource_id),
         weak_factory_(this) {
     // Leave cache headers out of resource bundle requests.
     response_info_.headers = extensions::BuildHttpHeaders(
         content_security_policy, send_cors_header, base::Time());
   }
 
   // Overridden from URLRequestSimpleJob:
-  int GetData(std::string* mime_type,
-              std::string* charset,
-              std::string* data,
-              const net::CompletionCallback& callback) const override {
+  int GetRefCountedData(
+      std::string* mime_type,
+      std::string* charset,
+      scoped_refptr<base::RefCountedMemory>* data,
+      const net::CompletionCallback& callback) const override {
     // TODO(vadimt): Remove ScopedTracker below once crbug.com/422489 is fixed.
     tracked_objects::ScopedTracker tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "422489 URLRequestResourceBundleJob::GetData"));
 
     const ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 
     // TODO(vadimt): Remove ScopedTracker below once crbug.com/422489 is fixed.
     tracked_objects::ScopedTracker tracking_profile1(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "422489 URLRequestResourceBundleJob::GetData 1"));
 
     const base::StringPiece resource_as_string_piece =
         rb.GetRawDataResource(resource_id_);

[mmenke, 2014/11/17 15:54:10]

Can't you just replace this with rb.LoadDataResourceBytes(resource_id_); which
already has code to create the RefCountedStaticMemory?

[Jeffrey Yasskin, 2014/11/17 17:16:23]

This winds up forcing a couple extra virtual calls, and some extra code to
create the StringPiece out of the RefCountedMemory, but done.

 
     // TODO(vadimt): Remove ScopedTracker below once crbug.com/422489 is fixed.
     tracked_objects::ScopedTracker tracking_profile15(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "422489 URLRequestResourceBundleJob::GetData 1.5"));
 
-    *data = resource_as_string_piece.as_string();
+    *data = new base::RefCountedStaticMemory(resource_as_string_piece.data(),
+                                             resource_as_string_piece.size());
 
     // TODO(vadimt): Remove ScopedTracker below once crbug.com/422489 is fixed.
     tracked_objects::ScopedTracker tracking_profile2(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "422489 URLRequestResourceBundleJob::GetData 2"));
 
     // Add the Content-Length header now that we know the resource length.
-    response_info_.headers->AddHeader(
-        base::StringPrintf("%s: %s",
-                           net::HttpRequestHeaders::kContentLength,
-                           base::UintToString(data->size()).c_str()));
+    response_info_.headers->AddHeader(base::StringPrintf(
+        "%s: %s", net::HttpRequestHeaders::kContentLength,
+        base::UintToString(resource_as_string_piece.size()).c_str()));
 
     // TODO(vadimt): Remove ScopedTracker below once crbug.com/422489 is fixed.
     tracked_objects::ScopedTracker tracking_profile3(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "422489 URLRequestResourceBundleJob::GetData 3"));
 
     std::string* read_mime_type = new std::string;
     bool posted = base::PostTaskAndReplyWithResult(
-        BrowserThread::GetBlockingPool(),
-        FROM_HERE,
-        base::Bind(&net::GetMimeTypeFromFile,
-                   filename_,
+        BrowserThread::GetBlockingPool(), FROM_HERE,
+        base::Bind(&net::GetMimeTypeFromFile, filename_,
                    base::Unretained(read_mime_type)),
         base::Bind(&URLRequestResourceBundleJob::OnMimeTypeRead,
-                   weak_factory_.GetWeakPtr(),
-                   mime_type,
-                   charset,
-                   data,
-                   base::Owned(read_mime_type),
+                   weak_factory_.GetWeakPtr(), mime_type, charset,
+                   resource_as_string_piece, base::Owned(read_mime_type),
                    callback));
     DCHECK(posted);
 
     return net::ERR_IO_PENDING;
   }
 
   void GetResponseInfo(net::HttpResponseInfo* info) override {
     *info = response_info_;
   }
 
  private:
   ~URLRequestResourceBundleJob() override {}
 
   void OnMimeTypeRead(std::string* out_mime_type,
                       std::string* charset,
-                      std::string* data,
+                      base::StringPiece data,
                       std::string* read_mime_type,
                       const net::CompletionCallback& callback,
                       bool read_result) {
     *out_mime_type = *read_mime_type;
     if (StartsWithASCII(*read_mime_type, "text/", false)) {
       // All of our HTML files should be UTF-8 and for other resource types
       // (like images), charset doesn't matter.
-      DCHECK(base::IsStringUTF8(*data));
+      DCHECK(base::IsStringUTF8(data));
       *charset = "utf-8";
     }
     int result = read_result ? net::OK : net::ERR_INVALID_URL;
     callback.Run(result);
   }
 
   // We need the filename of the resource to determine the mime type.
   base::FilePath filename_;
 
   // The resource bundle id to load.
@@ skipping 62 matching lines @@
                                              resource_id,
                                              content_security_policy,
                                              send_cors_header);
     }
   }
   return NULL;
 }
 
 }  // namespace chrome_url_request_util
 }  // namespace extensions