Stop using ResourceController in ResourceThrottle

content/browser/loader/resource_scheduler_unittest.cc

 // Copyright (c) 2012 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/resource_scheduler.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/timer/mock_timer.h"
 #include "base/timer/timer.h"
 #include "content/public/browser/resource_context.h"
-#include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_throttle.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/test/test_render_view_host_factory.h"
 #include "content/test/test_web_contents.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/url_request/url_request.h"
@@ skipping 13 matching lines @@
 const int kChildId = 30;
 const int kRouteId = 75;
 const int kChildId2 = 43;
 const int kRouteId2 = 67;
 const int kBackgroundChildId = 35;
 const int kBackgroundRouteId = 43;
 
 const char kPrioritySupportedRequestsDelayable[] =
     "PrioritySupportedRequestsDelayable";
 
-class TestRequest : public ResourceController {
+class TestRequest : public ResourceThrottle::Delegate {
  public:
   TestRequest(std::unique_ptr<net::URLRequest> url_request,
               std::unique_ptr<ResourceThrottle> throttle,
               ResourceScheduler* scheduler)
       : started_(false),
         url_request_(std::move(url_request)),
         throttle_(std::move(throttle)),
         scheduler_(scheduler) {
-    throttle_->set_controller_for_testing(this);
+    throttle_->set_delegate_for_testing(this);
   }
   ~TestRequest() override {
     // The URLRequest must still be valid when the ScheduledResourceRequest is
     // destroyed, so that it can unregister itself.
     throttle_.reset();
   }
 
   bool started() const { return started_; }
 
   void Start() {
     bool deferred = false;
     throttle_->WillStartRequest(&deferred);
     started_ = !deferred;
   }
 
   void ChangePriority(net::RequestPriority new_priority, int intra_priority) {
     scheduler_->ReprioritizeRequest(url_request_.get(), new_priority,
                                     intra_priority);
   }
 
   void Cancel() override {
     // Alert the scheduler that the request can be deleted.
     throttle_.reset();
   }
 
   const net::URLRequest* url_request() const { return url_request_.get(); }
 
  protected:
-  // ResourceController interface:
+  // ResourceThrottle::Delegate interface:
   void CancelAndIgnore() override {}
   void CancelWithError(int error_code) override {}
   void Resume() override { started_ = true; }
 
  private:
   bool started_;
   std::unique_ptr<net::URLRequest> url_request_;
   std::unique_ptr<ResourceThrottle> throttle_;
   ResourceScheduler* scheduler_;
 };
@@ skipping 723 matching lines @@
   scheduler_->OnClientDeleted(kChildId2, kRouteId2);
   high.reset();
   delayable_requests.clear();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(lowest->started());
 }
 
 }  // unnamed namespace
 
 }  // namespace content