| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "content/child/threaded_data_provider.h" | |
| 6 | |
| 7 #include "content/child/child_process.h" | |
| 8 #include "content/child/child_thread.h" | |
| 9 #include "content/child/resource_dispatcher.h" | |
| 10 #include "content/child/thread_safe_sender.h" | |
| 11 #include "content/child/webthread_impl.h" | |
| 12 #include "content/common/resource_messages.h" | |
| 13 #include "ipc/ipc_sync_channel.h" | |
| 14 #include "third_party/WebKit/public/platform/WebThread.h" | |
| 15 #include "third_party/WebKit/public/platform/WebThreadedDataReceiver.h" | |
| 16 | |
| 17 namespace content { | |
| 18 | |
| 19 namespace { | |
| 20 | |
| 21 class DataProviderMessageFilter : public IPC::MessageFilter { | |
| 22 public: | |
| 23 DataProviderMessageFilter( | |
| 24 const scoped_refptr<base::MessageLoopProxy>& io_message_loop, | |
| 25 base::MessageLoop* main_thread_message_loop, | |
| 26 const WebThreadImpl& background_thread, | |
| 27 const base::WeakPtr<ThreadedDataProvider>& | |
| 28 background_thread_resource_provider, | |
| 29 const base::WeakPtr<ThreadedDataProvider>& | |
| 30 main_thread_resource_provider, | |
| 31 int request_id); | |
| 32 | |
| 33 // IPC::ChannelProxy::MessageFilter | |
| 34 virtual void OnFilterAdded(IPC::Channel* channel) OVERRIDE FINAL; | |
| 35 virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE FINAL; | |
| 36 | |
| 37 private: | |
| 38 virtual ~DataProviderMessageFilter() { } | |
| 39 | |
| 40 void OnReceivedData(int request_id, int data_offset, int data_length, | |
| 41 int encoded_data_length); | |
| 42 | |
| 43 const scoped_refptr<base::MessageLoopProxy> io_message_loop_; | |
| 44 base::MessageLoop* main_thread_message_loop_; | |
| 45 const WebThreadImpl& background_thread_; | |
| 46 // This weakptr can only be dereferenced on the background thread. | |
| 47 base::WeakPtr<ThreadedDataProvider> | |
| 48 background_thread_resource_provider_; | |
| 49 // This weakptr can only be dereferenced on the main thread. | |
| 50 base::WeakPtr<ThreadedDataProvider> | |
| 51 main_thread_resource_provider_; | |
| 52 int request_id_; | |
| 53 }; | |
| 54 | |
| 55 DataProviderMessageFilter::DataProviderMessageFilter( | |
| 56 const scoped_refptr<base::MessageLoopProxy>& io_message_loop, | |
| 57 base::MessageLoop* main_thread_message_loop, | |
| 58 const WebThreadImpl& background_thread, | |
| 59 const base::WeakPtr<ThreadedDataProvider>& | |
| 60 background_thread_resource_provider, | |
| 61 const base::WeakPtr<ThreadedDataProvider>& | |
| 62 main_thread_resource_provider, | |
| 63 int request_id) | |
| 64 : io_message_loop_(io_message_loop), | |
| 65 main_thread_message_loop_(main_thread_message_loop), | |
| 66 background_thread_(background_thread), | |
| 67 background_thread_resource_provider_(background_thread_resource_provider), | |
| 68 main_thread_resource_provider_(main_thread_resource_provider), | |
| 69 request_id_(request_id) { | |
| 70 DCHECK(main_thread_message_loop != NULL); | |
| 71 } | |
| 72 | |
| 73 void DataProviderMessageFilter::OnFilterAdded(IPC::Channel* channel) { | |
| 74 DCHECK(io_message_loop_->BelongsToCurrentThread()); | |
| 75 | |
| 76 main_thread_message_loop_->PostTask(FROM_HERE, | |
| 77 base::Bind( | |
| 78 &ThreadedDataProvider::OnResourceMessageFilterAddedMainThread, | |
| 79 main_thread_resource_provider_)); | |
| 80 } | |
| 81 | |
| 82 bool DataProviderMessageFilter::OnMessageReceived( | |
| 83 const IPC::Message& message) { | |
| 84 DCHECK(io_message_loop_->BelongsToCurrentThread()); | |
| 85 | |
| 86 if (message.type() != ResourceMsg_DataReceived::ID) | |
| 87 return false; | |
| 88 | |
| 89 int request_id; | |
| 90 | |
| 91 PickleIterator iter(message); | |
| 92 if (!message.ReadInt(&iter, &request_id)) { | |
| 93 NOTREACHED() << "malformed resource message"; | |
| 94 return true; | |
| 95 } | |
| 96 | |
| 97 if (request_id == request_id_) { | |
| 98 ResourceMsg_DataReceived::Schema::Param arg; | |
| 99 if (ResourceMsg_DataReceived::Read(&message, &arg)) { | |
| 100 OnReceivedData(arg.a, arg.b, arg.c, arg.d); | |
| 101 return true; | |
| 102 } | |
| 103 } | |
| 104 | |
| 105 return false; | |
| 106 } | |
| 107 | |
| 108 void DataProviderMessageFilter::OnReceivedData(int request_id, | |
| 109 int data_offset, | |
| 110 int data_length, | |
| 111 int encoded_data_length) { | |
| 112 DCHECK(io_message_loop_->BelongsToCurrentThread()); | |
| 113 background_thread_.message_loop()->PostTask(FROM_HERE, base::Bind( | |
| 114 &ThreadedDataProvider::OnReceivedDataOnBackgroundThread, | |
| 115 background_thread_resource_provider_, | |
| 116 data_offset, data_length, encoded_data_length)); | |
| 117 } | |
| 118 | |
| 119 } // anonymous namespace | |
| 120 | |
| 121 ThreadedDataProvider::ThreadedDataProvider( | |
| 122 int request_id, blink::WebThreadedDataReceiver* threaded_data_receiver, | |
| 123 linked_ptr<base::SharedMemory> shm_buffer, int shm_size) | |
| 124 : request_id_(request_id), | |
| 125 shm_buffer_(shm_buffer), | |
| 126 shm_size_(shm_size), | |
| 127 main_thread_weak_factory_(this), | |
| 128 background_thread_( | |
| 129 static_cast<WebThreadImpl&>( | |
| 130 *threaded_data_receiver->backgroundThread())), | |
| 131 ipc_channel_(ChildThread::current()->channel()), | |
| 132 threaded_data_receiver_(threaded_data_receiver), | |
| 133 resource_filter_active_(false), | |
| 134 main_thread_message_loop_(ChildThread::current()->message_loop()) { | |
| 135 DCHECK(ChildThread::current()); | |
| 136 DCHECK(ipc_channel_); | |
| 137 DCHECK(threaded_data_receiver_); | |
| 138 DCHECK(main_thread_message_loop_); | |
| 139 | |
| 140 background_thread_weak_factory_.reset( | |
| 141 new base::WeakPtrFactory<ThreadedDataProvider>(this)); | |
| 142 | |
| 143 filter_ = new DataProviderMessageFilter( | |
| 144 ChildProcess::current()->io_message_loop_proxy(), | |
| 145 main_thread_message_loop_, | |
| 146 background_thread_, | |
| 147 background_thread_weak_factory_->GetWeakPtr(), | |
| 148 main_thread_weak_factory_.GetWeakPtr(), | |
| 149 request_id); | |
| 150 | |
| 151 ChildThread::current()->channel()->AddFilter(filter_); | |
| 152 } | |
| 153 | |
| 154 ThreadedDataProvider::~ThreadedDataProvider() { | |
| 155 DCHECK(ChildThread::current()); | |
| 156 | |
| 157 ChildThread::current()->channel()->RemoveFilter(filter_); | |
| 158 | |
| 159 delete threaded_data_receiver_; | |
| 160 } | |
| 161 | |
| 162 void DestructOnMainThread(ThreadedDataProvider* data_provider) { | |
| 163 DCHECK(ChildThread::current()); | |
| 164 | |
| 165 // The ThreadedDataProvider must be destructed on the main thread to | |
| 166 // be threadsafe when removing the message filter and releasing the shared | |
| 167 // memory buffer. | |
| 168 delete data_provider; | |
| 169 } | |
| 170 | |
| 171 void ThreadedDataProvider::Stop() { | |
| 172 DCHECK(ChildThread::current()); | |
| 173 | |
| 174 // Make sure we don't get called by on the main thread anymore via weak | |
| 175 // pointers we've passed to the filter. | |
| 176 main_thread_weak_factory_.InvalidateWeakPtrs(); | |
| 177 | |
| 178 // We can't destroy this instance directly; we need to bounce a message over | |
| 179 // to the background thread and back to make sure nothing else will access it | |
| 180 // there, before we can destruct it. | |
| 181 background_thread_.message_loop()->PostTask(FROM_HERE, | |
| 182 base::Bind(&ThreadedDataProvider::StopOnBackgroundThread, | |
| 183 base::Unretained(this))); | |
| 184 } | |
| 185 | |
| 186 void ThreadedDataProvider::StopOnBackgroundThread() { | |
| 187 DCHECK(background_thread_.isCurrentThread()); | |
| 188 DCHECK(background_thread_weak_factory_); | |
| 189 | |
| 190 // When this happens, the provider should no longer be called on the | |
| 191 // background thread as it's about to be destroyed on the main thread. | |
| 192 // Destructing the weak pointer factory means invalidating the weak pointers | |
| 193 // which means no callbacks from the filter will happen and nothing else will | |
| 194 // use this instance on the background thread. | |
| 195 background_thread_weak_factory_.reset(NULL); | |
| 196 main_thread_message_loop_->PostTask(FROM_HERE, | |
| 197 base::Bind(&DestructOnMainThread, this)); | |
| 198 } | |
| 199 | |
| 200 void ThreadedDataProvider::OnResourceMessageFilterAddedMainThread() { | |
| 201 DCHECK(ChildThread::current()); | |
| 202 DCHECK(background_thread_weak_factory_); | |
| 203 | |
| 204 // We bounce this message from the I/O thread via the main thread and then | |
| 205 // to our background thread, following the same path as incoming data before | |
| 206 // our filter gets added, to make sure there's nothing still incoming. | |
| 207 background_thread_.message_loop()->PostTask(FROM_HERE, | |
| 208 base::Bind( | |
| 209 &ThreadedDataProvider::OnResourceMessageFilterAddedBackgroundThread, | |
| 210 background_thread_weak_factory_->GetWeakPtr())); | |
| 211 } | |
| 212 | |
| 213 void ThreadedDataProvider::OnResourceMessageFilterAddedBackgroundThread() { | |
| 214 DCHECK(background_thread_.isCurrentThread()); | |
| 215 resource_filter_active_ = true; | |
| 216 | |
| 217 // At this point we know no more data is going to arrive from the main thread, | |
| 218 // so we can process any data we've received directly from the I/O thread | |
| 219 // in the meantime. | |
| 220 if (!queued_data_.empty()) { | |
| 221 std::vector<QueuedSharedMemoryData>::iterator iter = queued_data_.begin(); | |
| 222 for (; iter != queued_data_.end(); ++iter) { | |
| 223 ForwardAndACKData(iter->data, iter->length); | |
| 224 } | |
| 225 | |
| 226 queued_data_.clear(); | |
| 227 } | |
| 228 } | |
| 229 | |
| 230 void ThreadedDataProvider::OnReceivedDataOnBackgroundThread( | |
| 231 int data_offset, int data_length, int encoded_data_length) { | |
| 232 DCHECK(background_thread_.isCurrentThread()); | |
| 233 DCHECK(shm_buffer_ != NULL); | |
| 234 | |
| 235 CHECK_GE(shm_size_, data_offset + data_length); | |
| 236 const char* data_ptr = static_cast<char*>(shm_buffer_->memory()); | |
| 237 CHECK(data_ptr); | |
| 238 CHECK(data_ptr + data_offset); | |
| 239 | |
| 240 if (resource_filter_active_) { | |
| 241 ForwardAndACKData(data_ptr + data_offset, data_length); | |
| 242 } else { | |
| 243 // There's a brief interval between the point where we know the filter | |
| 244 // has been installed on the I/O thread, and when we know for sure there's | |
| 245 // no more data coming in from the main thread (from before the filter | |
| 246 // got added). If we get any data during that interval, we need to queue | |
| 247 // it until we're certain we've processed all the main thread data to make | |
| 248 // sure we forward (and ACK) everything in the right order. | |
| 249 QueuedSharedMemoryData queued_data; | |
| 250 queued_data.data = data_ptr + data_offset; | |
| 251 queued_data.length = data_length; | |
| 252 queued_data_.push_back(queued_data); | |
| 253 } | |
| 254 } | |
| 255 | |
| 256 void ThreadedDataProvider::OnReceivedDataOnForegroundThread( | |
| 257 const char* data, int data_length, int encoded_data_length) { | |
| 258 DCHECK(ChildThread::current()); | |
| 259 | |
| 260 background_thread_.message_loop()->PostTask(FROM_HERE, | |
| 261 base::Bind(&ThreadedDataProvider::ForwardAndACKData, | |
| 262 base::Unretained(this), | |
| 263 data, data_length)); | |
| 264 } | |
| 265 | |
| 266 void ThreadedDataProvider::ForwardAndACKData(const char* data, | |
| 267 int data_length) { | |
| 268 DCHECK(background_thread_.isCurrentThread()); | |
| 269 | |
| 270 // TODO(oysteine): SiteIsolationPolicy needs to be be checked | |
| 271 // here before we pass the data to the data provider | |
| 272 // (or earlier on the I/O thread), otherwise once SiteIsolationPolicy does | |
| 273 // actual blocking as opposed to just UMA logging this will bypass it. | |
| 274 threaded_data_receiver_->acceptData(data, data_length); | |
| 275 ipc_channel_->Send(new ResourceHostMsg_DataReceived_ACK(request_id_)); | |
| 276 } | |
| 277 | |
| 278 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 326403005:
Revert 275655 "Redirect HTML resource bytes directly to parser t..." (Closed)
Base URL: svn://svn.chromium.org/chrome/