naiveproxy/net/base/network_throttle_manager.h

// 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.

#ifndef NET_BASE_NETWORK_THROTTLE_MANAGER_H_
#define NET_BASE_NETWORK_THROTTLE_MANAGER_H_

#include <memory>

#include "base/memory/weak_ptr.h"
#include "net/base/net_export.h"
#include "net/base/request_priority.h"

namespace net {

// This class controls throttling based on priority level and number of
// outstanding requests.  It vends Throttle objects, and tracks
// outstanding requests by the lifetime of those objects.  Consumers
// determine whether or not they are throttled by consulting those
// Throttle objects.
//
// This class must outlive all Throttles created from it via CreateThrottle().
//
// Methods are virtual to allow for test mocks.
class NET_EXPORT_PRIVATE NetworkThrottleManager {
 public:
  class Throttle;

  // Abstract base class other classes can inherit from to get
  // notifications from throttle state changes.
  class NET_EXPORT_PRIVATE ThrottleDelegate {
   public:
    // Called when a throttle is unblocked.
    //
    // Note that this call may occur as the result of either a call to
    // Throttle::SetPriority (on the throttle related to this delegate
    // or another throttle) or the destruction of a Throttle, and if
    // so will occur synchronously during those events.  It will not
    // be called from the destructor of the Throttle associated with
    // the ThrottleDelegate.
    virtual void OnThrottleUnblocked(Throttle* throttle) = 0;

   protected:
    virtual ~ThrottleDelegate() {}
  };

  // Class owned by external stream representations that
  // routes notifications.  It may be constructed in either the
  // blocked or unblocked state according to the state of the
  // NetworkThrottleManager; if it's constructed in the unblocked
  // state, it will only make a single transition to unblocked,
  // which will be signaled by delegate->OnThrottleUnblocked(this).
  // If it's constructed in the unblocked state, it will remain
  // there.
  class NET_EXPORT_PRIVATE Throttle {
   public:
    virtual ~Throttle() {}

    virtual bool IsBlocked() const = 0;

    virtual RequestPriority Priority() const = 0;

    // Note that this may result in a possibly reentrant call to
    // |ThrottleDelegate::OnThrottleUnblocked|, as well as the resumption
    // of this or other requests, which may result in request completion
    // and destruction before return.  Any caller of this function
    // should not rely on this object or containing objects surviving
    // this call.
    //
    // This call is a no-op if the priority is set to its current value.
    virtual void SetPriority(RequestPriority priority) = 0;

   protected:
    Throttle() {}

   private:
    DISALLOW_COPY_AND_ASSIGN(Throttle);
  };

  virtual ~NetworkThrottleManager() {}

  // Caller must ensure that |*delegate| outlives the returned
  // Throttle.
  virtual std::unique_ptr<Throttle> CreateThrottle(ThrottleDelegate* delegate,
                                                   RequestPriority priority,
                                                   bool ignore_limits) = 0;

 protected:
  NetworkThrottleManager() {}

 private:
  DISALLOW_COPY_AND_ASSIGN(NetworkThrottleManager);
};

}  // namespace net

#endif  // NET_BASE_NETWORK_THROTTLE_MANAGER_H_