Implement CachedMetadata handling on MojoAsyncResourceHandler

content/browser/loader/mojo_async_resource_handler.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/browser/loader/mojo_async_resource_handler.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
@@ skipping 163 matching lines @@
   mojom::DownloadedTempFilePtr downloaded_file_ptr;
   if (!response->head.download_file_path.empty()) {
     downloaded_file_ptr = DownloadedTempFileImpl::Create(info->GetChildID(),
                                                          info->GetRequestID());
     rdh_->RegisterDownloadedTempFile(info->GetChildID(), info->GetRequestID(),
                                      response->head.download_file_path);
   }
 
   url_loader_client_->OnReceiveResponse(response->head,
                                         std::move(downloaded_file_ptr));
+
+  net::IOBufferWithSize* metadata = GetResponseMetadata(request());
+  if (metadata) {
+    const uint8_t* ptr = reinterpret_cast<const uint8_t*>(metadata->data());

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

nit:  Maybe ptr -> data?  data isn't exactly a detailed description, but "ptr"
seems even worse.

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

Done.

+
+    url_loader_client_->OnReceiveCachedMetadata(
+        std::vector<uint8_t>(ptr, ptr + metadata->size()));

[mmenke, 2017/01/13 15:55:04]

Not sure how big this tends to be, but can we somehow avoid a double-copy here? 
(Once to the vector, once to the IPC buffer)

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

This could be an interesting Mojo feature request. Mojo has something called
CArray (roughly analogous to StringPiece), but usually that's used in
StructTraits. So I suspect that if we were to wrap this in a struct with
typemapping, we would be able to remove a copy... but it would be nice not to
have to do that.

[yhirano, 2017/01/16 05:40:41]

How about adding net::IOBufferWithSize support to IPC?

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

It's a weird enough type that I don't think that's a great idea (What if we have
another net::IOBuffer subtype and a length, for instance?).  Some general way to
send an array + length as a vector without a copy seems like it would be better,
to me.

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

OK, let's leave it be. We'll be able to remove the copy when migrating
parameters. Note that we have this copy in AsyncResourceHandler too.

+  }

[mmenke, 2017/01/17 18:40:52]

Also, include <vector> (Same probably goes for both test cc files as well.

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

Done.

   return true;
 }
 
 bool MojoAsyncResourceHandler::OnWillStart(const GURL& url, bool* defer) {
   return true;
 }
 
 bool MojoAsyncResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                                           int* buf_size,
                                           int min_size) {
@@ skipping 122 matching lines @@
       shared_writer_->writer(), data, available, MOJO_WRITE_DATA_FLAG_NONE);
   if (result == MOJO_RESULT_OK)
     *available = std::min(*available, static_cast<uint32_t>(kMaxChunkSize));
   return result;
 }
 
 MojoResult MojoAsyncResourceHandler::EndWrite(uint32_t written) {
   return mojo::EndWriteDataRaw(shared_writer_->writer(), written);
 }
 
+net::IOBufferWithSize* MojoAsyncResourceHandler::GetResponseMetadata(
+    net::URLRequest* request) {
+  return request->response_info().metadata.get();
+}
+
 void MojoAsyncResourceHandler::OnResponseCompleted(
     const net::URLRequestStatus& status,
     bool* defer) {
   shared_writer_ = nullptr;
   buffer_ = nullptr;
   handle_watcher_.Cancel();
 
   const ResourceRequestInfoImpl* info = GetRequestInfo();
 
   // TODO(gavinp): Remove this CHECK when we figure out the cause of
@@ skipping 135 matching lines @@
     mojom::URLLoaderAssociatedRequest mojo_request,
     mojom::URLLoaderClientAssociatedPtr url_loader_client) {
   binding_.Unbind();
   binding_.Bind(std::move(mojo_request));
   binding_.set_connection_error_handler(
       base::Bind(&MojoAsyncResourceHandler::Cancel, base::Unretained(this)));
   url_loader_client_ = std::move(url_loader_client);
 }
 
 }  // namespace content