Avoid unnecessary copies in ImageDecoder.

chrome/browser/image_decoder.cc

 // Copyright (c) 2012 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/image_decoder.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/image_decoder.mojom.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/utility_process_host.h"
 #include "services/shell/public/cpp/interface_provider.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 46 matching lines @@
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 }
 
 ImageDecoder::ImageRequest::~ImageRequest() {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   ImageDecoder::Cancel(this);
 }
 
 // static
 void ImageDecoder::Start(ImageRequest* image_request,
+                         std::vector<uint8_t> image_data) {
+  StartWithOptions(image_request, std::move(image_data), DEFAULT_CODEC, false);
+}
+
+// static
+void ImageDecoder::Start(ImageRequest* image_request,
                          const std::string& image_data) {
-  StartWithOptions(image_request, image_data, DEFAULT_CODEC, false);
+  Start(image_request,
+        std::vector<uint8_t>(image_data.begin(), image_data.end()));
+}
+
+// static
+void ImageDecoder::StartWithOptions(ImageRequest* image_request,
+                                    std::vector<uint8_t> image_data,
+                                    ImageCodec image_codec,
+                                    bool shrink_to_fit) {
+  g_decoder.Pointer()->StartWithOptionsImpl(image_request,
+                                            std::move(image_data),
+                                            image_codec, shrink_to_fit);
 }
 
 // static
 void ImageDecoder::StartWithOptions(ImageRequest* image_request,
                                     const std::string& image_data,
                                     ImageCodec image_codec,
                                     bool shrink_to_fit) {
-  g_decoder.Pointer()->StartWithOptionsImpl(image_request, image_data,
-                                            image_codec, shrink_to_fit);
+  StartWithOptions(image_request,
+                   std::vector<uint8_t>(image_data.begin(), image_data.end()),
+                   image_codec, shrink_to_fit);
 }
 
 void ImageDecoder::StartWithOptionsImpl(ImageRequest* image_request,
-                                        const std::string& image_data,
+                                        std::vector<uint8_t> image_data,
                                         ImageCodec image_codec,
                                         bool shrink_to_fit) {
   DCHECK(image_request);
   DCHECK(image_request->task_runner());
 
   int request_id;
   {
     base::AutoLock lock(map_lock_);
     request_id = image_request_id_counter_++;
     image_request_id_map_.insert(std::make_pair(request_id, image_request));
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(
           &ImageDecoder::DecodeImageInSandbox,
           g_decoder.Pointer(), request_id,
-          std::vector<unsigned char>(image_data.begin(), image_data.end()),
+          base::Passed(std::move(image_data)),
           image_codec, shrink_to_fit));
 }
 
 // static
 void ImageDecoder::Cancel(ImageRequest* image_request) {
   DCHECK(image_request);
   g_decoder.Pointer()->CancelImpl(image_request);
 }
 
 void ImageDecoder::DecodeImageInSandbox(
     int request_id,
-    const std::vector<unsigned char>& image_data,
+    std::vector<uint8_t> image_data,
     ImageCodec image_codec,
     bool shrink_to_fit) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   base::AutoLock lock(map_lock_);
   const auto it = image_request_id_map_.find(request_id);
   if (it == image_request_id_map_.end())
     return;
 
   ImageRequest* image_request = it->second;
   if (!utility_process_host_) {
@@ skipping 19 matching lines @@
   batch_mode_timer_->Reset();
 
   mojom::ImageCodec mojo_codec = mojom::ImageCodec::DEFAULT;
 #if defined(OS_CHROMEOS)
   if (image_codec == ROBUST_JPEG_CODEC)
     mojo_codec = mojom::ImageCodec::ROBUST_JPEG;
   if (image_codec == ROBUST_PNG_CODEC)
     mojo_codec = mojom::ImageCodec::ROBUST_PNG;
 #endif  // defined(OS_CHROMEOS)
   decoder_->DecodeImage(
-      mojo::Array<uint8_t>::From(image_data),
+      mojo::Array<uint8_t>(std::move(image_data)),
       mojo_codec,
       shrink_to_fit,
       base::Bind(&OnDecodeImageDone,
                  base::Bind(&ImageDecoder::OnDecodeImageFailed, this),
                  base::Bind(&ImageDecoder::OnDecodeImageSucceeded, this),
                  request_id));
 }
 
 void ImageDecoder::CancelImpl(ImageRequest* image_request) {
   base::AutoLock lock(map_lock_);
@@ skipping 126 matching lines @@
     auto it = image_request_id_map_.find(request_id);
     if (it == image_request_id_map_.end())
       return;
     image_request = it->second;
     image_request_id_map_.erase(it);
   }
 
   DCHECK(image_request->task_runner()->RunsTasksOnCurrentThread());
   image_request->OnDecodeImageFailed();
 }