[Download Notification] Show preview if downloaded file is image

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 "base/bind.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/child_process_data.h"
+#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/utility_process_host.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 using content::UtilityProcessHost;
 
 namespace {
 
 // static, Leaky to allow access from any thread.
 base::LazyInstance<ImageDecoder>::Leaky g_decoder = LAZY_INSTANCE_INITIALIZER;
@@ skipping 24 matching lines @@
     : task_runner_(task_runner) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 }
 
 ImageDecoder::ImageRequest::~ImageRequest() {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   ImageDecoder::Cancel(this);
 }
 
 // static
+void ImageDecoder::StartByFilePath(
+    ImageRequest* image_request, const base::FilePath& image_file_path) {
+  g_decoder.Pointer()->StartWithOptionsImpl(image_request,
+                                            image_file_path, std::string(),
+                                            DEFAULT_CODEC, false);
+}
+
+// static
 void ImageDecoder::Start(ImageRequest* image_request,
                          const std::string& image_data) {
   StartWithOptions(image_request, image_data, DEFAULT_CODEC, false);
 }
 
 // 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,
+  g_decoder.Pointer()->StartWithOptionsImpl(image_request,
+                                            base::FilePath(), image_data,
                                             image_codec, shrink_to_fit);
 }
 
 void ImageDecoder::StartWithOptionsImpl(ImageRequest* image_request,
+                                        const base::FilePath& image_file_path,
                                         const std::string& image_data,
                                         ImageCodec image_codec,
                                         bool shrink_to_fit) {
   DCHECK(image_request);
   DCHECK(image_request->task_runner());
 
+  base::File image_file;
+  std::vector<unsigned char> image_data_vec;
+  if (!image_file_path.empty()) {
+    image_file.Initialize(image_file_path,
+                          base::File::FLAG_OPEN | base::File::FLAG_READ);
+  } else {
+    image_data_vec.assign(image_data.begin(), image_data.end());
+  }
+
   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()),
-          image_codec, shrink_to_fit));
+          base::Passed(image_file.Pass()),
+          image_data_vec, 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,
+    base::File image_file,
     const std::vector<unsigned char>& 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;
@@ skipping 14 matching lines @@
   if (!batch_mode_timer_) {
     // Created here so it will call StopBatchMode() on the right thread.
     batch_mode_timer_.reset(new base::DelayTimer<ImageDecoder>(
         FROM_HERE,
         base::TimeDelta::FromSeconds(kBatchModeTimeoutSeconds),
         this,
         &ImageDecoder::StopBatchMode));
   }
   batch_mode_timer_->Reset();
 
-  switch (image_codec) {
+  if (!image_data.empty()) {
+    switch (image_codec) {
 #if defined(OS_CHROMEOS)
-    case ROBUST_JPEG_CODEC:
-      utility_process_host_->Send(new ChromeUtilityMsg_RobustJPEGDecodeImage(
-          image_data, request_id));
-      break;
+      case ROBUST_JPEG_CODEC:
+        utility_process_host_->Send(new ChromeUtilityMsg_RobustJPEGDecodeImage(
+            image_data, request_id));
+        break;
 #endif  // defined(OS_CHROMEOS)
-    case DEFAULT_CODEC:
-      utility_process_host_->Send(new ChromeUtilityMsg_DecodeImage(
-          image_data, shrink_to_fit, request_id));
-      break;
+      case DEFAULT_CODEC:
+        utility_process_host_->Send(new ChromeUtilityMsg_DecodeImage(
+            image_data, shrink_to_fit, request_id));
+        break;
+    }
+  } else if (image_file.IsValid() && image_codec == DEFAULT_CODEC) {
+    base::ProcessHandle utility_process =
+        content::RenderProcessHost::run_renderer_in_process() ?
+            base::GetCurrentProcessHandle() :
+            utility_process_host_->GetData().handle;
+
+    utility_process_host_->Send(new ChromeUtilityMsg_DecodeImageByHandle(
+        IPC::TakeFileHandleForProcess(image_file.Pass(), utility_process),
+        shrink_to_fit, request_id));
+  } else {
+    image_request->task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&ImageDecoder::RunOnDecodeImageFailed, this, request_id));
   }
 }
 
 void ImageDecoder::CancelImpl(ImageRequest* image_request) {
   base::AutoLock lock(map_lock_);
   for (auto it = image_request_id_map_.begin();
        it != image_request_id_map_.end();) {
     if (it->second == image_request) {
       image_request_id_map_.erase(it++);
     } else {
@@ 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();
 }