Revert of Use associated interface on DownloadedTempFile

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 <algorithm>
 #include <utility>
 #include <vector>
 
-#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "content/browser/loader/downloaded_temp_file_impl.h"
 #include "content/browser/loader/netlog_observer.h"
 #include "content/browser/loader/resource_controller.h"
@@ skipping 31 matching lines @@
 
 void InitializeResourceBufferConstants() {
   static bool did_init = false;
   if (did_init)
     return;
   did_init = true;
 
   GetNumericArg("resource-buffer-size", &g_allocation_size);
 }
 
-void NotReached(mojom::URLLoaderAssociatedRequest mojo_request,
-                mojom::URLLoaderClientAssociatedPtr url_loader_client) {
-  NOTREACHED();
-}
-
 }  // namespace
 
 // This class is for sharing the ownership of a ScopedDataPipeProducerHandle
 // between WriterIOBuffer and MojoAsyncResourceHandler.
 class MojoAsyncResourceHandler::SharedWriter final
     : public base::RefCountedThreadSafe<SharedWriter> {
  public:
   explicit SharedWriter(mojo::ScopedDataPipeProducerHandle writer)
       : writer_(std::move(writer)) {}
   mojo::DataPipeProducerHandle writer() { return writer_.get(); }
@@ skipping 31 matching lines @@
   // This member is for keeping the writer alive.
   scoped_refptr<SharedWriter> writer_;
 
   DISALLOW_COPY_AND_ASSIGN(WriterIOBuffer);
 };
 
 MojoAsyncResourceHandler::MojoAsyncResourceHandler(
     net::URLRequest* request,
     ResourceDispatcherHostImpl* rdh,
     mojom::URLLoaderAssociatedRequest mojo_request,
-    mojom::URLLoaderClientAssociatedPtr url_loader_client,
-    ResourceType resource_type)
+    mojom::URLLoaderClientAssociatedPtr url_loader_client)
     : ResourceHandler(request),
       rdh_(rdh),
       binding_(this, std::move(mojo_request)),
       url_loader_client_(std::move(url_loader_client)),
       weak_factory_(this) {
   DCHECK(url_loader_client_);
   InitializeResourceBufferConstants();
   // This unretained pointer is safe, because |binding_| is owned by |this| and
   // the callback will never be called after |this| is destroyed.
   binding_.set_connection_error_handler(
       base::Bind(&MojoAsyncResourceHandler::Cancel, base::Unretained(this)));
 
-  if (IsResourceTypeFrame(resource_type)) {
-    GetRequestInfo()->set_on_transfer(base::Bind(
-        &MojoAsyncResourceHandler::OnTransfer, weak_factory_.GetWeakPtr()));
-  } else {
-    GetRequestInfo()->set_on_transfer(base::Bind(&NotReached));
-  }
+  GetRequestInfo()->set_on_transfer(base::Bind(
+      &MojoAsyncResourceHandler::OnTransfer, weak_factory_.GetWeakPtr()));
 }
 
 MojoAsyncResourceHandler::~MojoAsyncResourceHandler() {
   if (has_checked_for_sufficient_resources_)
     rdh_->FinishedWithResourcesForRequest(request());
 }
 
 bool MojoAsyncResourceHandler::OnRequestRedirected(
     const net::RedirectInfo& redirect_info,
     ResourceResponse* response,
@@ skipping 32 matching lines @@
   }
 
   NetLogObserver::PopulateResponseInfo(request(), response);
   response->head.encoded_data_length = request()->raw_header_size();
   reported_total_received_bytes_ = response->head.encoded_data_length;
 
   response->head.request_start = request()->creation_time();
   response->head.response_start = base::TimeTicks::Now();
   sent_received_response_message_ = true;
 
-  mojom::DownloadedTempFileAssociatedPtrInfo downloaded_file_ptr;
+  mojom::DownloadedTempFilePtr downloaded_file_ptr;
   if (!response->head.download_file_path.empty()) {
-    downloaded_file_ptr = DownloadedTempFileImpl::Create(
-        binding_.associated_group(), info->GetChildID(), info->GetRequestID());
+    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* data = reinterpret_cast<const uint8_t*>(metadata->data());
@@ skipping 339 matching lines @@
       base::Bind(&MojoAsyncResourceHandler::OnUploadProgressACK,
                  weak_factory_.GetWeakPtr()));
 }
 
 void MojoAsyncResourceHandler::OnUploadProgressACK() {
   if (upload_progress_tracker_)
     upload_progress_tracker_->OnAckReceived();
 }
 
 }  // namespace content