Implement CachedMetadata handling on MojoAsyncResourceHandler

content/child/url_loader_client_impl.cc

 // Copyright 2016 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/url_loader_client_impl.h"
 
 #include "base/callback.h"
 #include "base/single_thread_task_runner.h"
 #include "content/child/resource_dispatcher.h"
 #include "content/child/url_response_body_consumer.h"
@@ skipping 116 matching lines @@
   DCHECK(!body_consumer_);
   Dispatch(
       ResourceMsg_ReceivedRedirect(request_id_, redirect_info, response_head));
 }
 
 void URLLoaderClientImpl::OnDataDownloaded(int64_t data_len,
                                            int64_t encoded_data_len) {
   Dispatch(ResourceMsg_DataDownloaded(request_id_, data_len, encoded_data_len));
 }
 
+void URLLoaderClientImpl::OnReceiveCachedMetadata(
+    const std::vector<uint8_t>& data) {
+  const char* ptr = reinterpret_cast<const char*>(data.data());

[mmenke, 2017/01/17 18:39:57]

Again, suggest replacing ptr with data

[yhirano, 2017/01/18 06:22:42]

I'm using data_ptr as we are already using the name.

+  Dispatch(ResourceMsg_ReceivedCachedMetadata(
+      request_id_, std::vector<char>(ptr, ptr + data.size())));

[dcheng, 2017/01/14 11:30:17]

And I guess this is another copy =(

Is there any way we can be consistent with our types here? It's uint8_t on the
sending side and char on the receiving side.

[yhirano, 2017/01/16 05:25:46]

This is needed to reuse the current ResourceDispatcher code. I want to do that
during migration unless there's a significant performance regression. tzik@ will
measure the performance in this quarter, so I would like to fix performance
regressions after that. Are you fine with the plan?
It's char on both sending and receiving sides. You can see reinterpret_cast here
and in MojoAsyncResourceHandler.

[dcheng, 2017/01/18 00:23:53]

Sort of... we have to reinterpret_cast the original buffer to a uint8_t* to
construct a std::vector<uint8_t> out of it, and then we have to reinterpret_cast
it back on the other side.

It seems like we should be fixing the representation here to use
std::vector<uint8_t> throughout (though that's obviously out of scope of this
patch)

[yhirano, 2017/01/18 06:22:42]

Acknowledged.

+}
+
 void URLLoaderClientImpl::OnTransferSizeUpdated(int32_t transfer_size_diff) {
   if (is_deferred_) {
     accumulated_transfer_size_diff_during_deferred_ += transfer_size_diff;
   } else {
     resource_dispatcher_->OnTransferSizeUpdated(request_id_,
                                                 transfer_size_diff);
   }
 }
 
 void URLLoaderClientImpl::OnStartLoadingResponseBody(
@@ skipping 21 matching lines @@
     deferred_messages_.push_back(message);
   } else if (deferred_messages_.size() > 0) {
     deferred_messages_.push_back(message);
     FlushDeferredMessages();
   } else {
     resource_dispatcher_->DispatchMessage(message);
   }
 }
 
 }  // namespace content