[Mojo-Loading] Implement URLLoader::SetPriority

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"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_request_info_impl.h"
+#include "content/browser/loader/resource_scheduler.h"
 #include "content/browser/loader/upload_progress_tracker.h"
 #include "content/common/resource_request_completion_status.h"
 #include "content/public/browser/global_request_id.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/common/resource_response.h"
 #include "mojo/public/c/system/data_pipe.h"
 #include "mojo/public/cpp/bindings/message.h"
 #include "net/base/io_buffer.h"
 #include "net/base/mime_sniffer.h"
+#include "net/base/request_priority.h"
 #include "net/url_request/redirect_info.h"
 
 namespace content {
 namespace {
 
 int g_allocation_size = MojoAsyncResourceHandler::kDefaultAllocationSize;
 
 // MimeTypeResourceHandler *implicitly* requires that the buffer size
 // returned from OnWillRead should be larger than certain size.
 // TODO(yhirano): Fix MimeTypeResourceHandler.
@@ skipping 15 matching lines @@
   did_init = true;
 
   GetNumericArg("resource-buffer-size", &g_allocation_size);
 }
 
 void NotReached(mojom::URLLoaderAssociatedRequest mojo_request,
                 mojom::URLLoaderClientAssociatedPtr url_loader_client) {
   NOTREACHED();
 }
 
+net::RequestPriority NetRequestPriorityForMojoRequestPriority(
+    mojom::RequestPriority priority) {
+  switch (priority) {
+    case mojom::RequestPriority::kThrottled:
+      return net::THROTTLED;
+    case mojom::RequestPriority::kIdle:
+      return net::IDLE;
+    case mojom::RequestPriority::kLowest:
+      return net::LOWEST;
+    case mojom::RequestPriority::kLow:
+      return net::LOW;
+    case mojom::RequestPriority::kMedium:
+      return net::MEDIUM;
+    case mojom::RequestPriority::kHighest:
+      return net::HIGHEST;
+  }
+
+  NOTREACHED();
+  return static_cast<net::RequestPriority>(priority);
+}
+
 }  // 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 256 matching lines @@
     ReportBadMessage("Malformed FollowRedirect request");
     return;
   }
 
   DCHECK(!did_defer_on_writing_);
   did_defer_on_redirect_ = false;
   request()->LogUnblocked();
   controller()->Resume();
 }
 
+void MojoAsyncResourceHandler::SetPriority(mojom::RequestPriority priority,
+                                           int32_t intra_priority_value) {
+  ResourceDispatcherHostImpl::Get()->scheduler()->ReprioritizeRequest(
+      request(), NetRequestPriorityForMojoRequestPriority(priority),
+      intra_priority_value);
+}
+
 void MojoAsyncResourceHandler::OnWritableForTesting() {
   OnWritable(MOJO_RESULT_OK);
 }
 
 void MojoAsyncResourceHandler::SetAllocationSizeForTesting(size_t size) {
   g_allocation_size = size;
 }
 
 MojoResult MojoAsyncResourceHandler::BeginWrite(void** data,
                                                 uint32_t* available) {
@@ skipping 190 matching lines @@
       base::Bind(&MojoAsyncResourceHandler::OnUploadProgressACK,
                  weak_factory_.GetWeakPtr()));
 }
 
 void MojoAsyncResourceHandler::OnUploadProgressACK() {
   if (upload_progress_tracker_)
     upload_progress_tracker_->OnAckReceived();
 }
 
 }  // namespace content