Implement THROTTLED priority semantics.

net/http/http_network_transaction_unittest.cc

 // Copyright 2013 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 "net/http/http_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <stdint.h>
 
@@ skipping 116 matching lines @@
                                            bool ignore_limits) override {
     std::unique_ptr<TestThrottle> test_throttle(
         new TestThrottle(throttle_new_requests_, delegate, this));
     outstanding_throttles_.insert(test_throttle.get());
     return std::move(test_throttle);
   }
 
   void UnthrottleAllRequests() {
     std::set<TestThrottle*> outstanding_throttles_copy(outstanding_throttles_);
     for (auto& throttle : outstanding_throttles_copy) {
-      if (throttle->IsThrottled())
+      if (throttle->IsBlocked())
         throttle->Unthrottle();
     }
   }
 
   void set_throttle_new_requests(bool throttle_new_requests) {
     throttle_new_requests_ = throttle_new_requests;
   }
 
   // Includes both throttled and unthrottled throttles.
   size_t num_outstanding_requests() const {
     return outstanding_throttles_.size();
   }
 
   int num_set_priority_calls() const { return num_set_priority_calls_; }
   RequestPriority last_priority_set() const { return last_priority_set_; }
   void set_priority_change_closure(
       const base::Closure& priority_change_closure) {
     priority_change_closure_ = priority_change_closure;
   }
 
  private:
   class TestThrottle : public NetworkThrottleManager::Throttle {
    public:
     ~TestThrottle() override { throttler_->OnThrottleDestroyed(this); }
 
     // Throttle
-    bool IsThrottled() const override { return throttled_; }
+    bool IsBlocked() const override { return throttled_; }
+    RequestPriority Priority() const override {
+      NOTREACHED();
+      return IDLE;
+    }
     void SetPriority(RequestPriority priority) override {
       throttler_->SetPriorityCalled(priority);
     }
 
     TestThrottle(bool throttled,
                  ThrottleDelegate* delegate,
                  TestNetworkStreamThrottler* throttler)
         : throttled_(throttled), delegate_(delegate), throttler_(throttler) {}
 
     void Unthrottle() {
       EXPECT_TRUE(throttled_);
 
       throttled_ = false;
-      delegate_->OnThrottleStateChanged();
+      delegate_->OnThrottleUnblocked(this);
     }
 
     bool throttled_;
     ThrottleDelegate* delegate_;
     TestNetworkStreamThrottler* throttler_;
   };
 
   void OnThrottleDestroyed(TestThrottle* throttle) {
     EXPECT_NE(0u, outstanding_throttles_.count(throttle));
     outstanding_throttles_.erase(throttle);
@@ skipping 15691 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(trans.GetResponseInfo()->was_fetched_via_spdy);
   HttpRequestHeaders headers;
   ASSERT_TRUE(trans.GetFullRequestHeaders(&headers));
   EXPECT_TRUE(headers.HasHeader(HttpRequestHeaders::kTokenBinding));
 }
 #endif  // !defined(OS_IOS)
 
 }  // namespace net