Home | History | Annotate | Download | only in devtools 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/devtools/devtools_network_interceptor.h"
      6 
      7 #include <limits>
      8 
      9 #include "base/time/time.h"
     10 #include "chrome/browser/devtools/devtools_network_conditions.h"
     11 #include "chrome/browser/devtools/devtools_network_transaction.h"
     12 #include "net/base/load_timing_info.h"
     13 
     14 namespace {
     15 
     16 int64_t kPacketSize = 1500;
     17 
     18 }  // namespace
     19 
     20 DevToolsNetworkInterceptor::DevToolsNetworkInterceptor()
     21     : conditions_(new DevToolsNetworkConditions()),
     22       weak_ptr_factory_(this) {
     23 }
     24 
     25 DevToolsNetworkInterceptor::~DevToolsNetworkInterceptor() {
     26 }
     27 
     28 base::WeakPtr<DevToolsNetworkInterceptor>
     29 DevToolsNetworkInterceptor::GetWeakPtr() {
     30   return weak_ptr_factory_.GetWeakPtr();
     31 }
     32 
     33 void DevToolsNetworkInterceptor::AddTransaction(
     34     DevToolsNetworkTransaction* transaction) {
     35   DCHECK(transactions_.find(transaction) == transactions_.end());
     36   transactions_.insert(transaction);
     37 }
     38 
     39 void DevToolsNetworkInterceptor::RemoveTransaction(
     40     DevToolsNetworkTransaction* transaction) {
     41   DCHECK(transactions_.find(transaction) != transactions_.end());
     42   transactions_.erase(transaction);
     43 
     44   if (!conditions_->IsThrottling())
     45     return;
     46 
     47   base::TimeTicks now = base::TimeTicks::Now();
     48   UpdateThrottledTransactions(now);
     49   throttled_transactions_.erase(std::remove(throttled_transactions_.begin(),
     50       throttled_transactions_.end(), transaction),
     51       throttled_transactions_.end());
     52 
     53   SuspendedTransactions::iterator it = suspended_transactions_.begin();
     54   for (; it != suspended_transactions_.end(); ++it) {
     55     if (it->first == transaction) {
     56       suspended_transactions_.erase(it);
     57       break;
     58     }
     59   }
     60 
     61   ArmTimer(now);
     62 }
     63 
     64 void DevToolsNetworkInterceptor::UpdateConditions(
     65     scoped_ptr<DevToolsNetworkConditions> conditions) {
     66   DCHECK(conditions);
     67   base::TimeTicks now = base::TimeTicks::Now();
     68   if (conditions_->IsThrottling())
     69     UpdateThrottledTransactions(now);
     70 
     71   conditions_ = conditions.Pass();
     72 
     73   if (conditions_->offline()) {
     74     timer_.Stop();
     75     throttled_transactions_.clear();
     76     suspended_transactions_.clear();
     77     Transactions old_transactions(transactions_);
     78     Transactions::iterator it = old_transactions.begin();
     79     for (;it != old_transactions.end(); ++it) {
     80       if (transactions_.find(*it) == transactions_.end())
     81         continue;
     82       if (!(*it)->request() || (*it)->failed())
     83         continue;
     84       if (ShouldFail(*it))
     85         (*it)->Fail();
     86     }
     87     return;
     88   }
     89 
     90   if (conditions_->IsThrottling()) {
     91     DCHECK(conditions_->download_throughput() != 0);
     92     offset_ = now;
     93     last_tick_ = 0;
     94     int64_t us_tick_length =
     95         (1000000L * kPacketSize) / conditions_->download_throughput();
     96     DCHECK(us_tick_length != 0);
     97     if (us_tick_length == 0)
     98       us_tick_length = 1;
     99     tick_length_ = base::TimeDelta::FromMicroseconds(us_tick_length);
    100     latency_length_ = base::TimeDelta();
    101     double latency = conditions_->latency();
    102     if (latency > 0)
    103       latency_length_ = base::TimeDelta::FromMillisecondsD(latency);
    104     ArmTimer(now);
    105   } else {
    106     timer_.Stop();
    107 
    108     std::vector<DevToolsNetworkTransaction*> throttled_transactions;
    109     throttled_transactions.swap(throttled_transactions_);
    110     size_t throttle_count = throttled_transactions.size();
    111     for (size_t i = 0; i < throttle_count; ++i)
    112       FireThrottledCallback(throttled_transactions[i]);
    113 
    114     SuspendedTransactions suspended_transactions;
    115     suspended_transactions_.swap(suspended_transactions_);
    116     size_t suspend_count = suspended_transactions.size();
    117     for (size_t i = 0; i < suspend_count; ++i)
    118       FireThrottledCallback(suspended_transactions[i].first);
    119   }
    120 }
    121 
    122 void DevToolsNetworkInterceptor::FireThrottledCallback(
    123     DevToolsNetworkTransaction* transaction) {
    124   if (transactions_.find(transaction) != transactions_.end())
    125     transaction->FireThrottledCallback();
    126 }
    127 
    128 void DevToolsNetworkInterceptor::UpdateThrottledTransactions(
    129     base::TimeTicks now) {
    130   int64_t last_tick = (now - offset_) / tick_length_;
    131   int64_t ticks = last_tick - last_tick_;
    132   last_tick_ = last_tick;
    133 
    134   int64_t length = throttled_transactions_.size();
    135   if (!length) {
    136     UpdateSuspendedTransactions(now);
    137     return;
    138   }
    139 
    140   int64_t shift = ticks % length;
    141   for (int64_t i = 0; i < length; ++i) {
    142     throttled_transactions_[i]->DecreaseThrottledByteCount(
    143         (ticks / length) * kPacketSize + (i < shift ? kPacketSize : 0));
    144   }
    145   std::rotate(throttled_transactions_.begin(),
    146       throttled_transactions_.begin() + shift, throttled_transactions_.end());
    147 
    148   UpdateSuspendedTransactions(now);
    149 }
    150 
    151 void DevToolsNetworkInterceptor::UpdateSuspendedTransactions(
    152     base::TimeTicks now) {
    153   int64_t activation_baseline =
    154       (now - latency_length_ - base::TimeTicks()).InMicroseconds();
    155   SuspendedTransactions suspended_transactions;
    156   SuspendedTransactions::iterator it = suspended_transactions_.begin();
    157   for (; it != suspended_transactions_.end(); ++it) {
    158     if (it->second <= activation_baseline)
    159       throttled_transactions_.push_back(it->first);
    160     else
    161       suspended_transactions.push_back(*it);
    162   }
    163   suspended_transactions_.swap(suspended_transactions);
    164 }
    165 
    166 void DevToolsNetworkInterceptor::OnTimer() {
    167   base::TimeTicks now = base::TimeTicks::Now();
    168   UpdateThrottledTransactions(now);
    169 
    170   std::vector<DevToolsNetworkTransaction*> active_transactions;
    171   std::vector<DevToolsNetworkTransaction*> finished_transactions;
    172   size_t length = throttled_transactions_.size();
    173   for (size_t i = 0; i < length; ++i) {
    174     if (throttled_transactions_[i]->throttled_byte_count() < 0)
    175       finished_transactions.push_back(throttled_transactions_[i]);
    176     else
    177       active_transactions.push_back(throttled_transactions_[i]);
    178   }
    179   throttled_transactions_.swap(active_transactions);
    180 
    181   length = finished_transactions.size();
    182   for (size_t i = 0; i < length; ++i)
    183     FireThrottledCallback(finished_transactions[i]);
    184 
    185   ArmTimer(now);
    186 }
    187 
    188 void DevToolsNetworkInterceptor::ArmTimer(base::TimeTicks now) {
    189   size_t throttle_count = throttled_transactions_.size();
    190   size_t suspend_count = suspended_transactions_.size();
    191   if (!throttle_count && !suspend_count)
    192     return;
    193   int64_t min_ticks_left = 0x10000L;
    194   for (size_t i = 0; i < throttle_count; ++i) {
    195     int64_t packets_left = (throttled_transactions_[i]->throttled_byte_count() +
    196         kPacketSize - 1) / kPacketSize;
    197     int64_t ticks_left = (i + 1) + throttle_count * (packets_left - 1);
    198     if (i == 0 || ticks_left < min_ticks_left)
    199       min_ticks_left = ticks_left;
    200   }
    201   base::TimeTicks desired_time =
    202       offset_ + tick_length_ * (last_tick_ + min_ticks_left);
    203 
    204   int64_t min_baseline = std::numeric_limits<int64>::max();
    205   for (size_t i = 0; i < suspend_count; ++i) {
    206     if (suspended_transactions_[i].second < min_baseline)
    207       min_baseline = suspended_transactions_[i].second;
    208   }
    209   if (suspend_count) {
    210     base::TimeTicks activation_time = base::TimeTicks() +
    211         base::TimeDelta::FromMicroseconds(min_baseline) + latency_length_;
    212     if (activation_time < desired_time)
    213       desired_time = activation_time;
    214   }
    215 
    216   timer_.Start(
    217       FROM_HERE,
    218       desired_time - now,
    219       base::Bind(
    220           &DevToolsNetworkInterceptor::OnTimer,
    221           base::Unretained(this)));
    222 }
    223 
    224 void DevToolsNetworkInterceptor::ThrottleTransaction(
    225     DevToolsNetworkTransaction* transaction, bool start) {
    226   base::TimeTicks now = base::TimeTicks::Now();
    227   UpdateThrottledTransactions(now);
    228   if (start && latency_length_ != base::TimeDelta()) {
    229     net::LoadTimingInfo load_timing_info;
    230     base::TimeTicks send_end;
    231     if (transaction->GetLoadTimingInfo(&load_timing_info))
    232       send_end = load_timing_info.send_end;
    233     if (send_end.is_null())
    234       send_end = now;
    235     int64_t us_send_end = (send_end - base::TimeTicks()).InMicroseconds();
    236     suspended_transactions_.push_back(
    237         SuspendedTransaction(transaction, us_send_end));
    238     UpdateSuspendedTransactions(now);
    239   } else {
    240     throttled_transactions_.push_back(transaction);
    241   }
    242   ArmTimer(now);
    243 }
    244 
    245 bool DevToolsNetworkInterceptor::ShouldFail(
    246     const DevToolsNetworkTransaction* transaction) {
    247   if (!conditions_->offline())
    248     return false;
    249 
    250   if (!transaction->request_initiator().empty())
    251     return false;
    252 
    253   return true;
    254 }
    255 
    256 bool DevToolsNetworkInterceptor::ShouldThrottle(
    257     const DevToolsNetworkTransaction* transaction) {
    258   if (!conditions_->IsThrottling())
    259     return false;
    260 
    261   if (!transaction->request_initiator().empty())
    262     return false;
    263 
    264   return true;
    265 }
    266