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 <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/callback.h" | 10 #include "base/callback.h" |
11 #include "base/threading/thread_task_runner_handle.h" | 11 #include "base/threading/thread_task_runner_handle.h" |
12 #include "build/build_config.h" | 12 #include "build/build_config.h" |
13 #include "content/public/browser/browser_thread.h" | 13 #include "content/public/browser/browser_thread.h" |
14 #include "content/public/common/service_manager_connection.h" | 14 #include "content/public/common/service_manager_connection.h" |
15 #include "ipc/ipc_channel.h" | 15 #include "ipc/ipc_channel.h" |
16 #include "services/image_decoder/public/cpp/decode.h" | 16 #include "services/image_decoder/public/cpp/decode.h" |
17 #include "services/service_manager/public/cpp/connector.h" | 17 #include "services/service_manager/public/cpp/connector.h" |
18 #include "third_party/skia/include/core/SkBitmap.h" | 18 #include "third_party/skia/include/core/SkBitmap.h" |
19 #include "ui/gfx/geometry/size.h" | |
19 | 20 |
20 namespace { | 21 namespace { |
21 | 22 |
22 const int64_t kMaxImageSizeInBytes = | 23 const int64_t kMaxImageSizeInBytes = |
23 static_cast<int64_t>(IPC::Channel::kMaximumMessageSize); | 24 static_cast<int64_t>(IPC::Channel::kMaximumMessageSize); |
24 | 25 |
25 // Note that this is always called on the thread which initiated the | 26 // Note that this is always called on the thread which initiated the |
26 // corresponding image_decoder::Decode request. | 27 // corresponding image_decoder::Decode request. |
27 void OnDecodeImageDone( | 28 void OnDecodeImageDone( |
28 base::Callback<void(int)> fail_callback, | 29 base::Callback<void(int)> fail_callback, |
(...skipping 22 matching lines...) Expand all Loading... | |
51 const image_decoder::mojom::ImageDecoder::DecodeImageCallback& callback, | 52 const image_decoder::mojom::ImageDecoder::DecodeImageCallback& callback, |
52 scoped_refptr<base::SequencedTaskRunner> task_runner, | 53 scoped_refptr<base::SequencedTaskRunner> task_runner, |
53 const SkBitmap& image) { | 54 const SkBitmap& image) { |
54 task_runner->PostTask(FROM_HERE, base::Bind(callback, image)); | 55 task_runner->PostTask(FROM_HERE, base::Bind(callback, image)); |
55 } | 56 } |
56 | 57 |
57 void DecodeImage( | 58 void DecodeImage( |
58 std::vector<uint8_t> image_data, | 59 std::vector<uint8_t> image_data, |
59 image_decoder::mojom::ImageCodec codec, | 60 image_decoder::mojom::ImageCodec codec, |
60 bool shrink_to_fit, | 61 bool shrink_to_fit, |
62 const gfx::Size& desired_image_frame_size, | |
61 const image_decoder::mojom::ImageDecoder::DecodeImageCallback& callback, | 63 const image_decoder::mojom::ImageDecoder::DecodeImageCallback& callback, |
62 scoped_refptr<base::SequencedTaskRunner> callback_task_runner) { | 64 scoped_refptr<base::SequencedTaskRunner> callback_task_runner) { |
63 DCHECK_CURRENTLY_ON(content::BrowserThread::IO); | 65 DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
64 | 66 |
65 service_manager::mojom::ConnectorRequest connector_request; | 67 service_manager::mojom::ConnectorRequest connector_request; |
66 std::unique_ptr<service_manager::Connector> connector = | 68 std::unique_ptr<service_manager::Connector> connector = |
67 service_manager::Connector::Create(&connector_request); | 69 service_manager::Connector::Create(&connector_request); |
68 BindToBrowserConnector(std::move(connector_request)); | 70 BindToBrowserConnector(std::move(connector_request)); |
69 | 71 |
70 image_decoder::Decode(connector.get(), image_data, codec, shrink_to_fit, | 72 image_decoder::Decode(connector.get(), image_data, codec, shrink_to_fit, |
71 kMaxImageSizeInBytes, | 73 kMaxImageSizeInBytes, desired_image_frame_size, |
72 base::Bind(&RunDecodeCallbackOnTaskRunner, | 74 base::Bind(&RunDecodeCallbackOnTaskRunner, callback, |
73 callback, callback_task_runner)); | 75 callback_task_runner)); |
74 } | 76 } |
75 | 77 |
76 } // namespace | 78 } // namespace |
77 | 79 |
78 ImageDecoder::ImageRequest::ImageRequest() | 80 ImageDecoder::ImageRequest::ImageRequest() |
79 : task_runner_(base::ThreadTaskRunnerHandle::Get()) { | 81 : task_runner_(base::ThreadTaskRunnerHandle::Get()) { |
80 DCHECK(sequence_checker_.CalledOnValidSequence()); | 82 DCHECK(sequence_checker_.CalledOnValidSequence()); |
81 } | 83 } |
82 | 84 |
83 ImageDecoder::ImageRequest::ImageRequest( | 85 ImageDecoder::ImageRequest::ImageRequest( |
84 const scoped_refptr<base::SequencedTaskRunner>& task_runner) | 86 const scoped_refptr<base::SequencedTaskRunner>& task_runner) |
85 : task_runner_(task_runner) { | 87 : task_runner_(task_runner) { |
86 DCHECK(sequence_checker_.CalledOnValidSequence()); | 88 DCHECK(sequence_checker_.CalledOnValidSequence()); |
87 } | 89 } |
88 | 90 |
89 ImageDecoder::ImageRequest::~ImageRequest() { | 91 ImageDecoder::ImageRequest::~ImageRequest() { |
90 DCHECK(sequence_checker_.CalledOnValidSequence()); | 92 DCHECK(sequence_checker_.CalledOnValidSequence()); |
91 ImageDecoder::Cancel(this); | 93 ImageDecoder::Cancel(this); |
92 } | 94 } |
93 | 95 |
94 // static | 96 // static |
95 ImageDecoder* ImageDecoder::GetInstance() { | 97 ImageDecoder* ImageDecoder::GetInstance() { |
96 static auto* image_decoder = new ImageDecoder(); | 98 static auto* image_decoder = new ImageDecoder(); |
97 return image_decoder; | 99 return image_decoder; |
98 } | 100 } |
99 | 101 |
100 // static | 102 // static |
101 void ImageDecoder::Start(ImageRequest* image_request, | 103 void ImageDecoder::Start(ImageRequest* image_request, |
102 std::vector<uint8_t> image_data) { | 104 std::vector<uint8_t> image_data) { |
103 StartWithOptions(image_request, std::move(image_data), DEFAULT_CODEC, false); | 105 StartWithOptions(image_request, std::move(image_data), DEFAULT_CODEC, false, |
106 gfx::Size()); | |
104 } | 107 } |
105 | 108 |
106 // static | 109 // static |
107 void ImageDecoder::Start(ImageRequest* image_request, | 110 void ImageDecoder::Start(ImageRequest* image_request, |
108 const std::string& image_data) { | 111 const std::string& image_data) { |
109 Start(image_request, | 112 Start(image_request, |
110 std::vector<uint8_t>(image_data.begin(), image_data.end())); | 113 std::vector<uint8_t>(image_data.begin(), image_data.end())); |
111 } | 114 } |
112 | 115 |
113 // static | 116 // static |
114 void ImageDecoder::StartWithOptions(ImageRequest* image_request, | 117 void ImageDecoder::StartWithOptions(ImageRequest* image_request, |
115 std::vector<uint8_t> image_data, | 118 std::vector<uint8_t> image_data, |
116 ImageCodec image_codec, | 119 ImageCodec image_codec, |
117 bool shrink_to_fit) { | 120 bool shrink_to_fit, |
121 const gfx::Size& desired_image_frame_size) { | |
118 ImageDecoder::GetInstance()->StartWithOptionsImpl( | 122 ImageDecoder::GetInstance()->StartWithOptionsImpl( |
119 image_request, std::move(image_data), image_codec, shrink_to_fit); | 123 image_request, std::move(image_data), image_codec, shrink_to_fit); |
Mathieu
2017/03/01 14:36:23
sorry I'm confused, why don't we need to pass the
tschumann
2017/03/01 19:40:08
thanks for the catch! that's why we should have a
| |
120 } | 124 } |
121 | 125 |
122 // static | 126 // static |
123 void ImageDecoder::StartWithOptions(ImageRequest* image_request, | 127 void ImageDecoder::StartWithOptions(ImageRequest* image_request, |
124 const std::string& image_data, | 128 const std::string& image_data, |
125 ImageCodec image_codec, | 129 ImageCodec image_codec, |
126 bool shrink_to_fit) { | 130 bool shrink_to_fit) { |
127 StartWithOptions(image_request, | 131 StartWithOptions(image_request, |
128 std::vector<uint8_t>(image_data.begin(), image_data.end()), | 132 std::vector<uint8_t>(image_data.begin(), image_data.end()), |
129 image_codec, shrink_to_fit); | 133 image_codec, shrink_to_fit, gfx::Size()); |
130 } | 134 } |
131 | 135 |
132 ImageDecoder::ImageDecoder() : image_request_id_counter_(0) {} | 136 ImageDecoder::ImageDecoder() : image_request_id_counter_(0) {} |
133 | 137 |
134 void ImageDecoder::StartWithOptionsImpl(ImageRequest* image_request, | 138 void ImageDecoder::StartWithOptionsImpl( |
135 std::vector<uint8_t> image_data, | 139 ImageRequest* image_request, |
136 ImageCodec image_codec, | 140 std::vector<uint8_t> image_data, |
137 bool shrink_to_fit) { | 141 ImageCodec image_codec, |
142 bool shrink_to_fit, | |
143 const gfx::Size& desired_image_frame_size) { | |
138 DCHECK(image_request); | 144 DCHECK(image_request); |
139 DCHECK(image_request->task_runner()); | 145 DCHECK(image_request->task_runner()); |
140 | 146 |
141 int request_id; | 147 int request_id; |
142 { | 148 { |
143 base::AutoLock lock(map_lock_); | 149 base::AutoLock lock(map_lock_); |
144 request_id = image_request_id_counter_++; | 150 request_id = image_request_id_counter_++; |
145 image_request_id_map_.insert(std::make_pair(request_id, image_request)); | 151 image_request_id_map_.insert(std::make_pair(request_id, image_request)); |
146 } | 152 } |
147 | 153 |
(...skipping 12 matching lines...) Expand all Loading... | |
160 base::Bind(&ImageDecoder::OnDecodeImageSucceeded, base::Unretained(this)), | 166 base::Bind(&ImageDecoder::OnDecodeImageSucceeded, base::Unretained(this)), |
161 request_id); | 167 request_id); |
162 | 168 |
163 // NOTE: There exist ImageDecoder consumers which implicitly rely on this | 169 // NOTE: There exist ImageDecoder consumers which implicitly rely on this |
164 // operation happening on a thread which always has a ThreadTaskRunnerHandle. | 170 // operation happening on a thread which always has a ThreadTaskRunnerHandle. |
165 // We arbitrarily use the IO thread here to match details of the legacy | 171 // We arbitrarily use the IO thread here to match details of the legacy |
166 // implementation. | 172 // implementation. |
167 content::BrowserThread::PostTask( | 173 content::BrowserThread::PostTask( |
168 content::BrowserThread::IO, FROM_HERE, | 174 content::BrowserThread::IO, FROM_HERE, |
169 base::Bind(&DecodeImage, base::Passed(&image_data), codec, shrink_to_fit, | 175 base::Bind(&DecodeImage, base::Passed(&image_data), codec, shrink_to_fit, |
170 callback, make_scoped_refptr(image_request->task_runner()))); | 176 desired_image_frame_size, callback, |
177 make_scoped_refptr(image_request->task_runner()))); | |
171 } | 178 } |
172 | 179 |
173 // static | 180 // static |
174 void ImageDecoder::Cancel(ImageRequest* image_request) { | 181 void ImageDecoder::Cancel(ImageRequest* image_request) { |
175 DCHECK(image_request); | 182 DCHECK(image_request); |
176 ImageDecoder::GetInstance()->CancelImpl(image_request); | 183 ImageDecoder::GetInstance()->CancelImpl(image_request); |
177 } | 184 } |
178 | 185 |
179 void ImageDecoder::CancelImpl(ImageRequest* image_request) { | 186 void ImageDecoder::CancelImpl(ImageRequest* image_request) { |
180 base::AutoLock lock(map_lock_); | 187 base::AutoLock lock(map_lock_); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
212 auto it = image_request_id_map_.find(request_id); | 219 auto it = image_request_id_map_.find(request_id); |
213 if (it == image_request_id_map_.end()) | 220 if (it == image_request_id_map_.end()) |
214 return; | 221 return; |
215 image_request = it->second; | 222 image_request = it->second; |
216 image_request_id_map_.erase(it); | 223 image_request_id_map_.erase(it); |
217 } | 224 } |
218 | 225 |
219 DCHECK(image_request->task_runner()->RunsTasksOnCurrentThread()); | 226 DCHECK(image_request->task_runner()->RunsTasksOnCurrentThread()); |
220 image_request->OnDecodeImageFailed(); | 227 image_request->OnDecodeImageFailed(); |
221 } | 228 } |
OLD | NEW |