Make image_decoder a Leaky LazyInstance

chrome/utility/chrome_content_utility_client.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/utility/chrome_content_utility_client.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/memory/ref_counted.h"
@@ skipping 220 matching lines @@
       decoded_image.reset();
       LOG(ERROR) << "Decoded image too large for IPC message";
     }
   }
 
   return decoded_image;
 }
 
 // static
 void ChromeContentUtilityClient::DecodeImageAndSend(
-    const std::vector<unsigned char>& encoded_data, bool shrink_to_fit){
+    const std::vector<unsigned char>& encoded_data,
+    bool shrink_to_fit,
+    int request_id) {
   SkBitmap decoded_image = DecodeImage(encoded_data, shrink_to_fit);
 
   if (decoded_image.empty()) {
-    Send(new ChromeUtilityHostMsg_DecodeImage_Failed());
+    Send(new ChromeUtilityHostMsg_DecodeImage_Failed(request_id));
   } else {
-    Send(new ChromeUtilityHostMsg_DecodeImage_Succeeded(decoded_image));
+    Send(new ChromeUtilityHostMsg_DecodeImage_Succeeded(decoded_image,
+                                                        request_id));
   }
   ReleaseProcessIfNeeded();
 }
 
 void ChromeContentUtilityClient::OnDecodeImage(
-    const std::vector<unsigned char>& encoded_data, bool shrink_to_fit) {
-  DecodeImageAndSend(encoded_data, shrink_to_fit);
+    const std::vector<unsigned char>& encoded_data,
+    bool shrink_to_fit,
+    int request_id) {
+  DecodeImageAndSend(encoded_data, shrink_to_fit, request_id);
 }
 
 #if defined(OS_CHROMEOS)
 void ChromeContentUtilityClient::OnCreateZipFile(
     const base::FilePath& src_dir,
     const std::vector<base::FilePath>& src_relative_paths,
     const base::FileDescriptor& dest_fd) {
   // dest_fd should be closed in the function. See ipc/ipc_message_util.h for
   // details.
   base::ScopedFD fd_closer(dest_fd.fd);
@@ skipping 31 matching lines @@
   bool supports_syscall = sandbox::SandboxBPF::SupportsSeccompSandbox(
       sandbox::SandboxBPF::SeccompLevel::MULTI_THREADED);
   Send(new ChromeUtilityHostMsg_DetectSeccompSupport_ResultSyscall(
       supports_syscall));
 
   ReleaseProcessIfNeeded();
 }
 #endif  // defined(OS_ANDROID) && defined(USE_SECCOMP_BPF)
 
 void ChromeContentUtilityClient::OnRobustJPEGDecodeImage(
-    const std::vector<unsigned char>& encoded_data) {
+    const std::vector<unsigned char>& encoded_data,
+    int request_id) {
   // Our robust jpeg decoding is using IJG libjpeg.
   if (gfx::JPEGCodec::JpegLibraryVariant() == gfx::JPEGCodec::IJG_LIBJPEG &&
       !encoded_data.empty()) {
     scoped_ptr<SkBitmap> decoded_image(gfx::JPEGCodec::Decode(
         &encoded_data[0], encoded_data.size()));
     if (!decoded_image.get() || decoded_image->empty()) {
-      Send(new ChromeUtilityHostMsg_DecodeImage_Failed());
+      Send(new ChromeUtilityHostMsg_DecodeImage_Failed(request_id));
     } else {
-      Send(new ChromeUtilityHostMsg_DecodeImage_Succeeded(*decoded_image));
+      Send(new ChromeUtilityHostMsg_DecodeImage_Succeeded(*decoded_image,
+                                                          request_id));
     }
   } else {
-    Send(new ChromeUtilityHostMsg_DecodeImage_Failed());
+    Send(new ChromeUtilityHostMsg_DecodeImage_Failed(request_id));
   }
   ReleaseProcessIfNeeded();
 }
 
 void ChromeContentUtilityClient::OnParseJSON(const std::string& json) {
   int error_code;
   std::string error;
   base::Value* value = base::JSONReader::ReadAndReturnError(
       json, base::JSON_PARSE_RFC, &error_code, &error);
   if (value) {
@@ skipping 63 matching lines @@
     const std::string& mime_type, int64 total_size, bool get_attached_images) {
   // Only one IPCDataSource may be created and added to the list of handlers.
   metadata::IPCDataSource* source = new metadata::IPCDataSource(total_size);
   handlers_.push_back(source);
 
   metadata::MediaMetadataParser* parser = new metadata::MediaMetadataParser(
       source, mime_type, get_attached_images);
   parser->Start(base::Bind(&FinishParseMediaMetadata, base::Owned(parser)));
 }
 #endif