Make WebURLLoader capable of retaining received buffers.

content/child/threaded_data_provider.cc

 // Copyright 2014 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 "content/child/threaded_data_provider.h"
 
 #include "components/scheduler/child/webthread_impl_for_worker_scheduler.h"
 #include "content/child/child_process.h"
 #include "content/child/child_thread_impl.h"
+#include "content/child/ref_counted_shared_memory.h"
 #include "content/child/resource_dispatcher.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/resource_messages.h"
 #include "ipc/ipc_sync_channel.h"
 #include "third_party/WebKit/public/platform/WebThread.h"
 #include "third_party/WebKit/public/platform/WebThreadedDataReceiver.h"
 
 namespace content {
 
 namespace {
@@ skipping 93 matching lines @@
       base::Bind(&ThreadedDataProvider::OnReceivedDataOnBackgroundThread,
                  background_thread_resource_provider_, data_offset, data_length,
                  encoded_data_length));
 }
 
 }  // anonymous namespace
 
 ThreadedDataProvider::ThreadedDataProvider(
     int request_id,
     blink::WebThreadedDataReceiver* threaded_data_receiver,
-    linked_ptr<base::SharedMemory> shm_buffer,
+    scoped_refptr<RefCountedSharedMemory> shm_buffer,
     int shm_size,
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner)
     : request_id_(request_id),
       shm_buffer_(shm_buffer),
       shm_size_(shm_size),
       background_thread_(
           static_cast<scheduler::WebThreadImplForWorkerScheduler&>(
               *threaded_data_receiver->backgroundThread())),
       ipc_channel_(ChildThreadImpl::current()->channel()),
       threaded_data_receiver_(threaded_data_receiver),
@@ skipping 134 matching lines @@
     queued_data_.clear();
   }
 }
 
 void ThreadedDataProvider::OnReceivedDataOnBackgroundThread(
     int data_offset, int data_length, int encoded_data_length) {
   DCHECK(background_thread_.isCurrentThread());
   DCHECK(shm_buffer_ != NULL);
 
   CHECK_GE(shm_size_, data_offset + data_length);
-  const char* data_ptr = static_cast<char*>(shm_buffer_->memory());
+  const char* data_ptr = static_cast<char*>(shm_buffer_->memory().memory());
   CHECK(data_ptr);
   CHECK(data_ptr + data_offset);
 
   if (resource_filter_active_) {
     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
     // no more data coming in from the main thread (from before the filter
     // got added). If we get any data during that interval, we need to queue
@@ skipping 51 matching lines @@
     DCHECK(threaded_data_receiver_->needsMainthreadDataCopy());
     DCHECK_EQ((size_t)data_length, data_copy->size());
   }
 
   threaded_data_receiver_->acceptMainthreadDataNotification(
       (data_copy && !data_copy->empty()) ? &data_copy->front() : NULL,
       data_length, encoded_data_length);
 }
 
 }  // namespace content