Home | History | Annotate | Download | only in web_request 
      1 // Copyright (c) 2012 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/extensions/api/web_request/web_request_time_tracker.h"
      6 
      7 #include "testing/gmock/include/gmock/gmock.h"
      8 #include "testing/gtest/include/gtest/gtest.h"
      9 
     10 namespace {
     11 const base::TimeDelta kRequestDelta = base::TimeDelta::FromMilliseconds(100);
     12 const base::TimeDelta kTinyDelay = base::TimeDelta::FromMilliseconds(1);
     13 const base::TimeDelta kModerateDelay = base::TimeDelta::FromMilliseconds(25);
     14 const base::TimeDelta kExcessiveDelay = base::TimeDelta::FromMilliseconds(75);
     15 
     16 class ExtensionWebRequestTimeTrackerDelegateMock
     17     : public ExtensionWebRequestTimeTrackerDelegate {
     18  public:
     19   MOCK_METHOD4(NotifyExcessiveDelays,
     20       void (void*, size_t, size_t, const std::set<std::string>&));
     21   MOCK_METHOD4(NotifyModerateDelays,
     22       void (void*, size_t, size_t, const std::set<std::string>&));
     23 };
     24 
     25 }  // namespace
     26 
     27 //class ExtensionWebRequestTimeTrackerTest : public testing::Test {};
     28 
     29 TEST(ExtensionWebRequestTimeTrackerTest, Basic) {
     30   ExtensionWebRequestTimeTracker tracker;
     31   base::Time start;
     32   void* profile = NULL;
     33 
     34   tracker.LogRequestStartTime(42, start, GURL(), profile);
     35   EXPECT_EQ(1u, tracker.request_time_logs_.size());
     36   ASSERT_EQ(1u, tracker.request_ids_.size());
     37   EXPECT_EQ(42, tracker.request_ids_.front());
     38   tracker.LogRequestEndTime(42, start + kRequestDelta);
     39   EXPECT_EQ(1u, tracker.request_time_logs_.size());
     40   EXPECT_EQ(0u, tracker.moderate_delays_.size());
     41   EXPECT_EQ(0u, tracker.excessive_delays_.size());
     42 }
     43 
     44 TEST(ExtensionWebRequestTimeTrackerTest, CancelOrRedirect) {
     45   ExtensionWebRequestTimeTracker tracker;
     46   base::Time start;
     47   void* profile = NULL;
     48 
     49   tracker.LogRequestStartTime(1, start, GURL(), profile);
     50   EXPECT_EQ(1u, tracker.request_time_logs_.size());
     51   tracker.SetRequestCanceled(1);
     52   tracker.LogRequestEndTime(1, start + kRequestDelta);
     53   EXPECT_EQ(0u, tracker.request_time_logs_.size());
     54 
     55   tracker.LogRequestStartTime(2, start, GURL(), profile);
     56   EXPECT_EQ(1u, tracker.request_time_logs_.size());
     57   tracker.SetRequestRedirected(2);
     58   tracker.LogRequestEndTime(2, start + kRequestDelta);
     59   EXPECT_EQ(0u, tracker.request_time_logs_.size());
     60 }
     61 
     62 TEST(ExtensionWebRequestTimeTrackerTest, Delays) {
     63   ExtensionWebRequestTimeTracker tracker;
     64   base::Time start;
     65   std::string extension1_id("1");
     66   std::string extension2_id("2");
     67   void* profile = NULL;
     68 
     69   // Start 3 requests with different amounts of delay from 2 extensions.
     70   tracker.LogRequestStartTime(1, start, GURL(), profile);
     71   tracker.LogRequestStartTime(2, start, GURL(), profile);
     72   tracker.LogRequestStartTime(3, start, GURL(), profile);
     73   tracker.IncrementExtensionBlockTime(extension1_id, 1, kTinyDelay);
     74   tracker.IncrementExtensionBlockTime(extension1_id, 2, kTinyDelay);
     75   tracker.IncrementExtensionBlockTime(extension1_id, 3, kTinyDelay);
     76   tracker.IncrementExtensionBlockTime(extension2_id, 2, kModerateDelay);
     77   tracker.IncrementExtensionBlockTime(extension2_id, 3, kExcessiveDelay);
     78   tracker.IncrementTotalBlockTime(1, kTinyDelay);
     79   tracker.IncrementTotalBlockTime(2, kModerateDelay);
     80   tracker.IncrementTotalBlockTime(3, kExcessiveDelay);
     81   tracker.LogRequestEndTime(1, start + kRequestDelta);
     82   tracker.LogRequestEndTime(2, start + kRequestDelta);
     83   tracker.LogRequestEndTime(3, start + kRequestDelta);
     84   EXPECT_EQ(3u, tracker.request_time_logs_.size());
     85   EXPECT_EQ(1u, tracker.moderate_delays_.size());
     86   EXPECT_EQ(1u, tracker.moderate_delays_.count(2));
     87   EXPECT_EQ(1u, tracker.excessive_delays_.size());
     88   EXPECT_EQ(1u, tracker.excessive_delays_.count(3));
     89 
     90   // Now issue a bunch more requests and ensure that the old delays are
     91   // forgotten.
     92   for (int64 i = 4; i < 500; ++i) {
     93     tracker.LogRequestStartTime(i, start, GURL(), profile);
     94     tracker.LogRequestEndTime(i, start + kRequestDelta);
     95   }
     96   EXPECT_EQ(0u, tracker.moderate_delays_.size());
     97   EXPECT_EQ(0u, tracker.excessive_delays_.size());
     98 }
     99 
    100 TEST(ExtensionWebRequestTimeTrackerTest, Delegate) {
    101   using testing::_;
    102   using testing::Mock;
    103 
    104   ExtensionWebRequestTimeTrackerDelegateMock* delegate(
    105       new ExtensionWebRequestTimeTrackerDelegateMock);
    106   ExtensionWebRequestTimeTracker tracker;
    107   tracker.SetDelegate(delegate);
    108   base::Time start;
    109   std::string extension1_id("1");
    110   void* profile = NULL;
    111   // Set of all extensions that blocked network requests.
    112   std::set<std::string> extensions;
    113   extensions.insert(extension1_id);
    114 
    115   const int num_moderate_delays = 51;
    116   const int num_excessive_delays = 11;
    117   int request_nr = 0;
    118 
    119   // Check that (only) the last moderate delay triggers the delegate callback.
    120   for (int64 i = 0; i < num_moderate_delays; ++i) {
    121     request_nr++;
    122     if (i == num_moderate_delays-1) {
    123       EXPECT_CALL(*delegate,
    124                   NotifyModerateDelays(profile , i+1, request_nr, extensions));
    125     }
    126     tracker.LogRequestStartTime(request_nr, start, GURL(), profile);
    127     tracker.IncrementExtensionBlockTime(extension1_id, request_nr,
    128                                         kModerateDelay);
    129     tracker.IncrementTotalBlockTime(request_nr, kModerateDelay);
    130     tracker.LogRequestEndTime(request_nr, start + kRequestDelta);
    131     Mock::VerifyAndClearExpectations(delegate);
    132   }
    133 
    134   // Check that (only) the last excessive delay triggers the delegate callback.
    135   for (int64 i = 0; i < num_excessive_delays; ++i) {
    136     request_nr++;
    137     if (i == num_excessive_delays-1) {
    138       EXPECT_CALL(*delegate,
    139                   NotifyExcessiveDelays(profile, i+1, request_nr, extensions));
    140     }
    141     tracker.LogRequestStartTime(request_nr, start, GURL(), profile);
    142     tracker.IncrementExtensionBlockTime(extension1_id, request_nr,
    143                                         kExcessiveDelay);
    144     tracker.IncrementTotalBlockTime(request_nr, kExcessiveDelay);
    145     tracker.LogRequestEndTime(request_nr, start + kRequestDelta);
    146     Mock::VerifyAndClearExpectations(delegate);
    147   }
    148 }
    149