Threaded data provider: Support main thread data notifications (Chrome side)

content/child/threaded_data_provider.cc

Index: content/child/threaded_data_provider.cc
diff --git a/content/child/threaded_data_provider.cc b/content/child/threaded_data_provider.cc
index ccfe8918cc4037161e020bd3f7fc1b1a1e03d3cd..8ce6d5c49200ef47a66937546d31a35f4cbdb2fc 100644
--- a/content/child/threaded_data_provider.cc
+++ b/content/child/threaded_data_provider.cc
@@ -206,6 +206,33 @@ void ThreadedDataProvider::StopOnBackgroundThread() {
                                      base::Bind(&DestructOnMainThread, this));
 }
 
+void ThreadedDataProvider::OnRequestCompleteForegroundThread(
+      base::WeakPtr<ResourceDispatcher> resource_dispatcher,
+      const ResourceMsg_RequestCompleteData& request_complete_data,
+      const base::TimeTicks& renderer_completion_time) {
+  DCHECK(ChildThread::current());
+
+  background_thread_.message_loop()->PostTask(FROM_HERE,
+      base::Bind(&ThreadedDataProvider::OnRequestCompleteBackgroundThread,
+                 base::Unretained(this), resource_dispatcher,
+                 request_complete_data, renderer_completion_time));
+}
+
+void ThreadedDataProvider::OnRequestCompleteBackgroundThread(
+      base::WeakPtr<ResourceDispatcher> resource_dispatcher,
+      const ResourceMsg_RequestCompleteData& request_complete_data,
+      const base::TimeTicks& renderer_completion_time) {
+  DCHECK(background_thread_.isCurrentThread());
+
+  main_thread_task_runner_->PostTask(FROM_HERE,
+      base::Bind(
+          &ResourceDispatcher::CompletedRequestAfterBackgroundThreadFlush,
+          resource_dispatcher,
+          request_id_,
+          request_complete_data,
+          renderer_completion_time));
+}
+
 void ThreadedDataProvider::OnResourceMessageFilterAddedMainThread() {
   DCHECK(ChildThread::current());
   DCHECK(background_thread_weak_factory_);
@@ -229,7 +256,7 @@ void ThreadedDataProvider::OnResourceMessageFilterAddedBackgroundThread() {
   if (!queued_data_.empty()) {
     std::vector<QueuedSharedMemoryData>::iterator iter = queued_data_.begin();
     for (; iter != queued_data_.end(); ++iter) {
-      ForwardAndACKData(iter->data, iter->length);
+      ForwardAndACKData(iter->data, iter->length, iter->encoded_length);
     }
 
     queued_data_.clear();
@@ -247,7 +274,7 @@ void ThreadedDataProvider::OnReceivedDataOnBackgroundThread(
   CHECK(data_ptr + data_offset);
 
   if (resource_filter_active_) {
-    ForwardAndACKData(data_ptr + data_offset, data_length);
+    ForwardAndACKData(data_ptr + data_offset, data_length, encoded_data_length);
   } else {
     // There's a brief interval between the point where we know the filter
     // has been installed on the I/O thread, and when we know for sure there's
@@ -258,6 +285,7 @@ void ThreadedDataProvider::OnReceivedDataOnBackgroundThread(
     QueuedSharedMemoryData queued_data;
     queued_data.data = data_ptr + data_offset;
     queued_data.length = data_length;
+    queued_data.encoded_length = encoded_data_length;
     queued_data_.push_back(queued_data);
   }
 }
@@ -269,11 +297,12 @@ void ThreadedDataProvider::OnReceivedDataOnForegroundThread(
   background_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&ThreadedDataProvider::ForwardAndACKData,
                  base::Unretained(this),
-                 data, data_length));
+                 data, data_length, encoded_data_length));
 }
 
 void ThreadedDataProvider::ForwardAndACKData(const char* data,
-                                             int data_length) {
+                                             int data_length,
+                                             int encoded_data_length) {
   DCHECK(background_thread_.isCurrentThread());
 
   // TODO(oysteine): SiteIsolationPolicy needs to be be checked
@@ -281,7 +310,31 @@ void ThreadedDataProvider::ForwardAndACKData(const char* data,
   // (or earlier on the I/O thread), otherwise once SiteIsolationPolicy does
   // actual blocking as opposed to just UMA logging this will bypass it.
   threaded_data_receiver_->acceptData(data, data_length);
+
+  scoped_ptr<std::vector<char> > data_copy;
+  if (threaded_data_receiver_->needsMainthreadDataCopy()) {

[davidben, 2015/01/23 19:46:43]

Can needsMainthreadDataCopy be called on both threads? (Here and line 334.)

[oystein (OOO til 10th of July), 2015/01/23 21:23:47]

Yep, it's threadsafe.

+    data_copy.reset(new std::vector<char>(data_length));
+    memcpy(data_copy->data(), data, data_length);
+  }
+
+  main_thread_task_runner_->PostTask(FROM_HERE,
+      base::Bind(&ThreadedDataProvider::DataNotifyForegroundThread,
+          base::Unretained(this),
+          base::Passed(&data_copy),
+          data_length,
+          encoded_data_length));
+
   ipc_channel_->Send(new ResourceHostMsg_DataReceived_ACK(request_id_));
 }
 
+void ThreadedDataProvider::DataNotifyForegroundThread(
+    scoped_ptr<std::vector<char> > data_copy,
+    int data_length,
+    int encoded_data_length) {
+  DCHECK(!data_copy || threaded_data_receiver_->needsMainthreadDataCopy());

[davidben, 2015/01/23 19:46:43]

Nit: I'd maybe also DCHECK something like
if (data_copy)
  DCHECK_EQ(data_length, data->size());
(Probably will need to cast something to size_t.)

[oystein (OOO til 10th of July), 2015/01/23 21:23:47]

Done.

+
+  threaded_data_receiver_->acceptMainthreadDataNotification(
+      data_copy ? data_copy->data() : NULL, data_length, encoded_data_length);

[davidben, 2015/01/23 19:46:43]

std::vector::data is a C++11-ism. I don't think all of our STLs have it yet.
(Notably stlport on Android.)

[oystein (OOO til 10th of July), 2015/01/23 21:23:47]

Done.

+}
+
 }  // namespace content