OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/image_decoder.h" | 5 #include "chrome/browser/image_decoder.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "chrome/browser/browser_process.h" | 8 #include "chrome/browser/browser_process.h" |
9 #include "chrome/common/chrome_utility_messages.h" | 9 #include "chrome/common/chrome_utility_messages.h" |
10 #include "content/public/browser/browser_thread.h" | 10 #include "content/public/browser/browser_thread.h" |
11 #include "content/public/browser/utility_process_host.h" | 11 #include "content/public/browser/utility_process_host.h" |
12 | 12 |
13 using content::BrowserThread; | 13 using content::BrowserThread; |
14 using content::UtilityProcessHost; | 14 using content::UtilityProcessHost; |
15 | 15 |
16 ImageDecoder::ImageDecoder(Delegate* delegate, | 16 namespace { |
17 const std::string& image_data, | 17 |
18 ImageCodec image_codec) | 18 // static, Leaky to allow access from any thread. |
19 : delegate_(delegate), | 19 base::LazyInstance<ImageDecoder>::Leaky g_decoder = LAZY_INSTANCE_INITIALIZER; |
20 image_data_(image_data.begin(), image_data.end()), | 20 |
21 image_codec_(image_codec), | 21 // How long to wait after the last request has been received before ending |
22 task_runner_(NULL), | 22 // batch mode. |
23 shrink_to_fit_(false) { | 23 const int kBatchModeTimeoutSeconds = 5; |
| 24 |
| 25 } // namespace |
| 26 |
| 27 ImageDecoder::ImageDecoder() |
| 28 : image_request_id_counter_(0), last_request_(base::TimeTicks::Now()) { |
| 29 // A single ImageDecoder instance should live for the life of the program. |
| 30 // Explicitly add a reference so the object isn't deleted. |
| 31 AddRef(); |
24 } | 32 } |
25 | 33 |
26 ImageDecoder::ImageDecoder(Delegate* delegate, | 34 ImageDecoder::~ImageDecoder() { |
27 const std::vector<char>& image_data, | |
28 ImageCodec image_codec) | |
29 : delegate_(delegate), | |
30 image_data_(image_data.begin(), image_data.end()), | |
31 image_codec_(image_codec), | |
32 task_runner_(NULL), | |
33 shrink_to_fit_(false) { | |
34 } | 35 } |
35 | 36 |
36 ImageDecoder::~ImageDecoder() {} | 37 ImageDecoder::ImageRequest::ImageRequest( |
37 | 38 const scoped_refptr<base::SequencedTaskRunner>& task_runner) |
38 void ImageDecoder::Start(scoped_refptr<base::SequencedTaskRunner> task_runner) { | 39 : task_runner_(task_runner) { |
39 task_runner_ = task_runner; | |
40 BrowserThread::PostTask( | |
41 BrowserThread::IO, FROM_HERE, | |
42 base::Bind(&ImageDecoder::DecodeImageInSandbox, this, image_data_)); | |
43 } | 40 } |
44 | 41 |
45 bool ImageDecoder::OnMessageReceived(const IPC::Message& message) { | 42 ImageDecoder::ImageRequest::~ImageRequest() { |
| 43 ImageDecoder::Cancel(this); |
| 44 } |
| 45 |
| 46 // static |
| 47 void ImageDecoder::Start(ImageRequest* image_request, |
| 48 const std::string& image_data) { |
| 49 StartWithOptions(image_request, image_data, DEFAULT_CODEC, false); |
| 50 } |
| 51 |
| 52 // static |
| 53 void ImageDecoder::StartWithOptions(ImageRequest* image_request, |
| 54 const std::string& image_data, |
| 55 ImageCodec image_codec, |
| 56 bool shrink_to_fit) { |
| 57 DCHECK(image_request); |
| 58 DCHECK(image_request->task_runner()); |
| 59 BrowserThread::PostTask( |
| 60 BrowserThread::IO, FROM_HERE, |
| 61 base::Bind( |
| 62 &ImageDecoder::DecodeImageInSandbox, |
| 63 g_decoder.Pointer(), image_request, |
| 64 std::vector<unsigned char>(image_data.begin(), image_data.end()), |
| 65 image_codec, shrink_to_fit)); |
| 66 } |
| 67 |
| 68 // static |
| 69 void ImageDecoder::Cancel(ImageRequest* image_request) { |
| 70 DCHECK(image_request); |
| 71 g_decoder.Pointer()->CancelImpl(image_request); |
| 72 } |
| 73 |
| 74 void ImageDecoder::DecodeImageInSandbox( |
| 75 ImageRequest* image_request, |
| 76 const std::vector<unsigned char>& image_data, |
| 77 ImageCodec image_codec, |
| 78 bool shrink_to_fit) { |
| 79 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 80 if (!utility_process_host_) { |
| 81 StartBatchMode(); |
| 82 } |
| 83 |
| 84 last_request_ = base::TimeTicks::Now(); |
| 85 base::AutoLock lock(map_lock_); |
| 86 image_request_id_map_.insert( |
| 87 std::make_pair(image_request_id_counter_, image_request)); |
| 88 |
| 89 switch (image_codec) { |
| 90 case ROBUST_JPEG_CODEC: |
| 91 utility_process_host_->Send(new ChromeUtilityMsg_RobustJPEGDecodeImage( |
| 92 image_data, image_request_id_counter_)); |
| 93 break; |
| 94 case DEFAULT_CODEC: |
| 95 utility_process_host_->Send(new ChromeUtilityMsg_DecodeImage( |
| 96 image_data, shrink_to_fit, image_request_id_counter_)); |
| 97 break; |
| 98 } |
| 99 |
| 100 ++image_request_id_counter_; |
| 101 } |
| 102 |
| 103 void ImageDecoder::CancelImpl(ImageRequest* image_request) { |
| 104 base::AutoLock lock(map_lock_); |
| 105 for (auto it = image_request_id_map_.begin(); |
| 106 it != image_request_id_map_.end();) { |
| 107 if (it->second == image_request) { |
| 108 image_request_id_map_.erase(it++); |
| 109 } else { |
| 110 ++it; |
| 111 } |
| 112 } |
| 113 } |
| 114 |
| 115 void ImageDecoder::StartBatchMode() { |
| 116 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 117 utility_process_host_ = |
| 118 UtilityProcessHost::Create(this, base::MessageLoopProxy::current().get()) |
| 119 ->AsWeakPtr(); |
| 120 utility_process_host_->StartBatchMode(); |
| 121 batch_mode_timer_.Start( |
| 122 FROM_HERE, base::TimeDelta::FromSeconds(kBatchModeTimeoutSeconds), |
| 123 this, &ImageDecoder::StopBatchMode); |
| 124 } |
| 125 |
| 126 void ImageDecoder::StopBatchMode() { |
| 127 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 128 if ((base::TimeTicks::Now() - last_request_) |
| 129 < base::TimeDelta::FromSeconds(kBatchModeTimeoutSeconds)) { |
| 130 return; |
| 131 } |
| 132 |
| 133 if (utility_process_host_) { |
| 134 utility_process_host_->EndBatchMode(); |
| 135 utility_process_host_.reset(); |
| 136 } |
| 137 batch_mode_timer_.Stop(); |
| 138 } |
| 139 |
| 140 bool ImageDecoder::OnMessageReceived( |
| 141 const IPC::Message& message) { |
46 bool handled = true; | 142 bool handled = true; |
47 IPC_BEGIN_MESSAGE_MAP(ImageDecoder, message) | 143 IPC_BEGIN_MESSAGE_MAP(ImageDecoder, message) |
48 IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_DecodeImage_Succeeded, | 144 IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_DecodeImage_Succeeded, |
49 OnDecodeImageSucceeded) | 145 OnDecodeImageSucceeded) |
50 IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_DecodeImage_Failed, | 146 IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_DecodeImage_Failed, |
51 OnDecodeImageFailed) | 147 OnDecodeImageFailed) |
52 IPC_MESSAGE_UNHANDLED(handled = false) | 148 IPC_MESSAGE_UNHANDLED(handled = false) |
53 IPC_END_MESSAGE_MAP() | 149 IPC_END_MESSAGE_MAP() |
54 return handled; | 150 return handled; |
55 } | 151 } |
56 | 152 |
57 void ImageDecoder::OnDecodeImageSucceeded(const SkBitmap& decoded_image) { | 153 void ImageDecoder::OnDecodeImageSucceeded( |
58 DCHECK(task_runner_->RunsTasksOnCurrentThread()); | 154 const SkBitmap& decoded_image, |
59 if (delegate_) | 155 int request_id) { |
60 delegate_->OnImageDecoded(this, decoded_image); | 156 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
| 157 base::AutoLock lock(map_lock_); |
| 158 auto it = image_request_id_map_.find(request_id); |
| 159 if (it != image_request_id_map_.end()) { |
| 160 ImageRequest* image_request = it->second; |
| 161 image_request->task_runner()->PostTask( |
| 162 FROM_HERE, base::Bind(&ImageRequest::OnImageDecoded, |
| 163 base::Unretained(image_request), decoded_image)); |
| 164 |
| 165 image_request_id_map_.erase(it); |
| 166 } |
61 } | 167 } |
62 | 168 |
63 void ImageDecoder::OnDecodeImageFailed() { | 169 void ImageDecoder::OnDecodeImageFailed(int request_id) { |
64 DCHECK(task_runner_->RunsTasksOnCurrentThread()); | 170 DCHECK_CURRENTLY_ON(BrowserThread::IO); |
65 if (delegate_) | 171 base::AutoLock lock(map_lock_); |
66 delegate_->OnDecodeImageFailed(this); | 172 auto it = image_request_id_map_.find(request_id); |
67 } | 173 if (it != image_request_id_map_.end()) { |
| 174 ImageRequest* image_request = it->second; |
| 175 image_request->task_runner()->PostTask( |
| 176 FROM_HERE, base::Bind(&ImageRequest::OnDecodeImageFailed, |
| 177 base::Unretained(image_request))); |
68 | 178 |
69 void ImageDecoder::DecodeImageInSandbox( | 179 image_request_id_map_.erase(it); |
70 const std::vector<unsigned char>& image_data) { | |
71 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
72 UtilityProcessHost* utility_process_host; | |
73 utility_process_host = UtilityProcessHost::Create(this, task_runner_.get()); | |
74 if (image_codec_ == ROBUST_JPEG_CODEC) { | |
75 utility_process_host->Send( | |
76 new ChromeUtilityMsg_RobustJPEGDecodeImage(image_data)); | |
77 } else { | |
78 utility_process_host->Send( | |
79 new ChromeUtilityMsg_DecodeImage(image_data, shrink_to_fit_)); | |
80 } | 180 } |
81 } | 181 } |
OLD | NEW |