Merge ResourceRequestBodyImpl and ResourceRequestBody.

content/browser/service_worker/service_worker_url_request_job.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/browser/service_worker/service_worker_url_request_job.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 15 matching lines @@
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/browser/resource_context_impl.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/service_worker_blob_reader.h"
 #include "content/browser/service_worker/service_worker_data_pipe_reader.h"
 #include "content/browser/service_worker/service_worker_fetch_dispatcher.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/service_worker/service_worker_response_info.h"
-#include "content/common/resource_request_body_impl.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/blob_handle.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/service_worker_context.h"
 #include "content/public/common/referrer.h"
+#include "content/public/common/resource_request_body.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/log/net_log.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_with_source.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
@@ skipping 96 matching lines @@
 
   void Resolve(base::TaskRunner* file_runner,
                const base::Callback<void(bool)>& callback) {
     DCHECK_EQ(static_cast<int>(Phase::INITIAL), static_cast<int>(phase_));
     DCHECK(file_elements_.empty());
     phase_ = Phase::WAITING;
     body_ = owner_->body_;
     callback_ = callback;
 
     std::vector<base::FilePath> file_paths;
-    for (ResourceRequestBodyImpl::Element& element :
-         *body_->elements_mutable()) {
-      if (element.type() == ResourceRequestBodyImpl::Element::TYPE_FILE &&
-          element.length() == ResourceRequestBodyImpl::Element::kUnknownSize) {
+    for (ResourceRequestBody::Element& element : *body_->elements_mutable()) {
+      if (element.type() == ResourceRequestBody::Element::TYPE_FILE &&
+          element.length() == ResourceRequestBody::Element::kUnknownSize) {
         file_elements_.push_back(&element);
         file_paths.push_back(element.path());
       }
     }
     if (file_elements_.empty()) {
       Complete(true);
       return;
     }
 
     PostTaskAndReplyWithResult(
         file_runner, FROM_HERE,
         base::Bind(&GetFileSizesOnBlockingPool, base::Passed(&file_paths)),
         base::Bind(
             &ServiceWorkerURLRequestJob::FileSizeResolver::OnFileSizesResolved,
             weak_factory_.GetWeakPtr()));
   }
 
  private:
   enum class Phase { INITIAL, WAITING, SUCCESS, FAIL };
 
   void OnFileSizesResolved(std::vector<int64_t> sizes) {
     bool success = !sizes.empty();
     if (success) {
       DCHECK_EQ(sizes.size(), file_elements_.size());
       size_t num_elements = file_elements_.size();
       for (size_t i = 0; i < num_elements; i++) {
-        ResourceRequestBodyImpl::Element* element = file_elements_[i];
+        ResourceRequestBody::Element* element = file_elements_[i];
         element->SetToFilePathRange(element->path(), element->offset(),
                                     base::checked_cast<uint64_t>(sizes[i]),
                                     element->expected_modification_time());
       }
       file_elements_.clear();
     }
     Complete(success);
   }
 
   void Complete(bool success) {
     DCHECK_EQ(static_cast<int>(Phase::WAITING), static_cast<int>(phase_));
     phase_ = success ? Phase::SUCCESS : Phase::FAIL;
     // Destroys |this|, so we use a copy.
     base::ResetAndReturn(&callback_).Run(success);
   }
 
   // Owns and must outlive |this|.
   ServiceWorkerURLRequestJob* owner_;
 
-  scoped_refptr<ResourceRequestBodyImpl> body_;
-  std::vector<ResourceRequestBodyImpl::Element*> file_elements_;
+  scoped_refptr<ResourceRequestBody> body_;
+  std::vector<ResourceRequestBody::Element*> file_elements_;
   base::Callback<void(bool)> callback_;
   Phase phase_ = Phase::INITIAL;
   base::WeakPtrFactory<FileSizeResolver> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSizeResolver);
 };
 
 // A helper for recording navigation preload UMA. The UMA is recorded
 // after both service worker preparation finished and the
 // navigation preload response arrived.
@@ skipping 90 matching lines @@
     net::NetworkDelegate* network_delegate,
     const std::string& client_id,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
     const ResourceContext* resource_context,
     FetchRequestMode request_mode,
     FetchCredentialsMode credentials_mode,
     FetchRedirectMode redirect_mode,
     ResourceType resource_type,
     RequestContextType request_context_type,
     RequestContextFrameType frame_type,
-    scoped_refptr<ResourceRequestBodyImpl> body,
+    scoped_refptr<ResourceRequestBody> body,
     ServiceWorkerFetchType fetch_type,
     const base::Optional<base::TimeDelta>& timeout,
     Delegate* delegate)
     : net::URLRequestJob(request, network_delegate),
       delegate_(delegate),
       response_type_(NOT_DETERMINED),
       is_started_(false),
       service_worker_response_type_(
           blink::kWebServiceWorkerResponseTypeDefault),
       client_id_(client_id),
@@ skipping 254 matching lines @@
         Referrer(GURL(request_->referrer()), blink::kWebReferrerPolicyDefault);
   }
   request->fetch_type = fetch_type_;
   return request;
 }
 
 void ServiceWorkerURLRequestJob::CreateRequestBodyBlob(std::string* blob_uuid,
                                                        uint64_t* blob_size) {
   DCHECK(HasRequestBody());
   storage::BlobDataBuilder blob_builder(base::GenerateGUID());
-  for (const ResourceRequestBodyImpl::Element& element : (*body_->elements())) {
+  for (const ResourceRequestBody::Element& element : (*body_->elements())) {
     blob_builder.AppendIPCDataElement(element);
   }
 
   request_body_blob_data_handle_ =
       blob_storage_context_->AddFinishedBlob(&blob_builder);
   *blob_uuid = blob_builder.uuid();
   *blob_size = request_body_blob_data_handle_->size();
 }
 
 bool ServiceWorkerURLRequestJob::ShouldRecordNavigationMetrics(
@@ skipping 385 matching lines @@
                        weak_factory_.GetWeakPtr()));
   }
   fetch_dispatcher_->Run();
 }
 
 void ServiceWorkerURLRequestJob::OnNavigationPreloadResponse() {
   nav_preload_metrics_->ReportNavigationPreloadFinished();
 }
 
 }  // namespace content