Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(88)

Side by Side Diff: net/http/http_cache_unittest.cc

Issue 10834313: Add histograms for network activity, and total/cumulative (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/
Patch Set: Created 8 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 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 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "net/http/http_cache.h" 5 #include "net/http/http_cache.h"
6 6
7 #include "base/bind.h" 7 #include "base/bind.h"
8 #include "base/bind_helpers.h" 8 #include "base/bind_helpers.h"
9 #include "base/memory/scoped_vector.h" 9 #include "base/memory/scoped_vector.h"
10 #include "base/message_loop.h" 10 #include "base/message_loop.h"
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
55 net::CompletionCallback callback_; 55 net::CompletionCallback callback_;
56 56
57 DISALLOW_COPY_AND_ASSIGN(DeleteCacheCompletionCallback); 57 DISALLOW_COPY_AND_ASSIGN(DeleteCacheCompletionCallback);
58 }; 58 };
59 59
60 //----------------------------------------------------------------------------- 60 //-----------------------------------------------------------------------------
61 // helpers 61 // helpers
62 62
63 class TestHttpTransactionDelegate : public net::HttpTransactionDelegate { 63 class TestHttpTransactionDelegate : public net::HttpTransactionDelegate {
64 public: 64 public:
65 explicit TestHttpTransactionDelegate(int num_actions_to_observe) 65 TestHttpTransactionDelegate(int num_cache_actions_to_observe,
66 : num_remaining_actions_to_observe_(num_actions_to_observe), 66 int num_network_actions_to_observe)
67 action_in_progress_(false) { 67 : num_remaining_cache_actions_to_observe_(num_cache_actions_to_observe),
68 num_remaining_network_actions_to_observe_(
69 num_network_actions_to_observe),
70 cache_action_in_progress_(false),
71 network_action_in_progress_(false) {
68 } 72 }
69 virtual ~TestHttpTransactionDelegate() { 73 virtual ~TestHttpTransactionDelegate() {
70 EXPECT_EQ(0, num_remaining_actions_to_observe_); 74 EXPECT_EQ(0, num_remaining_cache_actions_to_observe_);
71 EXPECT_FALSE(action_in_progress_); 75 EXPECT_EQ(0, num_remaining_network_actions_to_observe_);
76 EXPECT_FALSE(cache_action_in_progress_);
77 EXPECT_FALSE(network_action_in_progress_);
72 } 78 }
73 virtual void OnCacheActionStart() { 79 virtual void OnCacheActionStart() {
74 EXPECT_FALSE(action_in_progress_); 80 EXPECT_FALSE(cache_action_in_progress_);
75 EXPECT_GT(num_remaining_actions_to_observe_, 0); 81 EXPECT_FALSE(network_action_in_progress_);
76 num_remaining_actions_to_observe_--; 82 EXPECT_GT(num_remaining_cache_actions_to_observe_, 0);
77 action_in_progress_ = true; 83 num_remaining_cache_actions_to_observe_--;
84 cache_action_in_progress_ = true;
78 } 85 }
79 virtual void OnCacheActionFinish() { 86 virtual void OnCacheActionFinish() {
80 EXPECT_TRUE(action_in_progress_); 87 EXPECT_TRUE(cache_action_in_progress_);
81 action_in_progress_ = false; 88 cache_action_in_progress_ = false;
89 }
90 virtual void OnNetworkActionStart() {
91 EXPECT_FALSE(cache_action_in_progress_);
92 EXPECT_FALSE(network_action_in_progress_);
93 EXPECT_GT(num_remaining_network_actions_to_observe_, 0);
94 num_remaining_network_actions_to_observe_--;
95 network_action_in_progress_ = true;
96 }
97 virtual void OnNetworkActionFinish() {
98 EXPECT_TRUE(network_action_in_progress_);
99 network_action_in_progress_ = false;
82 } 100 }
83 101
84 private: 102 private:
85 int num_remaining_actions_to_observe_; 103 int num_remaining_cache_actions_to_observe_;
86 bool action_in_progress_; 104 int num_remaining_network_actions_to_observe_;
105 bool cache_action_in_progress_;
106 bool network_action_in_progress_;
87 }; 107 };
88 108
89 void ReadAndVerifyTransaction(net::HttpTransaction* trans, 109 void ReadAndVerifyTransaction(net::HttpTransaction* trans,
90 const MockTransaction& trans_info) { 110 const MockTransaction& trans_info) {
91 std::string content; 111 std::string content;
92 int rv = ReadTransaction(trans, &content); 112 int rv = ReadTransaction(trans, &content);
93 113
94 EXPECT_EQ(net::OK, rv); 114 EXPECT_EQ(net::OK, rv);
95 std::string expected(trans_info.data); 115 std::string expected(trans_info.data);
96 EXPECT_EQ(expected, content); 116 EXPECT_EQ(expected, content);
97 } 117 }
98 118
99 const int kNoDelegateTransactionCheck = -1; 119 const int kNoDelegateTransactionCheck = -1;
100 120
101 void RunTransactionTestWithRequestAndLogAndDelegate( 121 void RunTransactionTestWithRequestAndLogAndDelegate(
102 net::HttpCache* cache, 122 net::HttpCache* cache,
103 const MockTransaction& trans_info, 123 const MockTransaction& trans_info,
104 const MockHttpRequest& request, 124 const MockHttpRequest& request,
105 net::HttpResponseInfo* response_info, 125 net::HttpResponseInfo* response_info,
106 const net::BoundNetLog& net_log, 126 const net::BoundNetLog& net_log,
107 int num_delegate_actions) { 127 int num_cache_delegate_actions,
128 int num_network_delegate_actions) {
108 net::TestCompletionCallback callback; 129 net::TestCompletionCallback callback;
109 130
110 // write to the cache 131 // write to the cache
111 132
112 scoped_ptr<TestHttpTransactionDelegate> delegate; 133 scoped_ptr<TestHttpTransactionDelegate> delegate;
113 if (num_delegate_actions != kNoDelegateTransactionCheck) { 134 if (num_cache_delegate_actions != kNoDelegateTransactionCheck &&
114 delegate.reset(new TestHttpTransactionDelegate(num_delegate_actions)); 135 num_network_delegate_actions != kNoDelegateTransactionCheck) {
136 delegate.reset(
137 new TestHttpTransactionDelegate(num_cache_delegate_actions,
138 num_network_delegate_actions));
115 } 139 }
116 scoped_ptr<net::HttpTransaction> trans; 140 scoped_ptr<net::HttpTransaction> trans;
117 int rv = cache->CreateTransaction(&trans, delegate.get()); 141 int rv = cache->CreateTransaction(&trans, delegate.get());
118 EXPECT_EQ(net::OK, rv); 142 EXPECT_EQ(net::OK, rv);
119 ASSERT_TRUE(trans.get()); 143 ASSERT_TRUE(trans.get());
120 144
121 rv = trans->Start(&request, callback.callback(), net_log); 145 rv = trans->Start(&request, callback.callback(), net_log);
122 if (rv == net::ERR_IO_PENDING) 146 if (rv == net::ERR_IO_PENDING)
123 rv = callback.WaitForResult(); 147 rv = callback.WaitForResult();
124 ASSERT_EQ(net::OK, rv); 148 ASSERT_EQ(net::OK, rv);
125 149
126 const net::HttpResponseInfo* response = trans->GetResponseInfo(); 150 const net::HttpResponseInfo* response = trans->GetResponseInfo();
127 ASSERT_TRUE(response); 151 ASSERT_TRUE(response);
128 152
129 if (response_info) 153 if (response_info)
130 *response_info = *response; 154 *response_info = *response;
131 155
132 ReadAndVerifyTransaction(trans.get(), trans_info); 156 ReadAndVerifyTransaction(trans.get(), trans_info);
133 } 157 }
134 158
135 void RunTransactionTestWithRequest(net::HttpCache* cache, 159 void RunTransactionTestWithRequest(net::HttpCache* cache,
136 const MockTransaction& trans_info, 160 const MockTransaction& trans_info,
137 const MockHttpRequest& request, 161 const MockHttpRequest& request,
138 net::HttpResponseInfo* response_info) { 162 net::HttpResponseInfo* response_info) {
139 RunTransactionTestWithRequestAndLogAndDelegate( 163 RunTransactionTestWithRequestAndLogAndDelegate(
140 cache, trans_info, request, response_info, net::BoundNetLog(), 164 cache, trans_info, request, response_info, net::BoundNetLog(),
141 kNoDelegateTransactionCheck); 165 kNoDelegateTransactionCheck, kNoDelegateTransactionCheck);
142 } 166 }
143 167
144 void RunTransactionTestWithLog(net::HttpCache* cache, 168 void RunTransactionTestWithLog(net::HttpCache* cache,
145 const MockTransaction& trans_info, 169 const MockTransaction& trans_info,
146 const net::BoundNetLog& log) { 170 const net::BoundNetLog& log) {
147 RunTransactionTestWithRequestAndLogAndDelegate( 171 RunTransactionTestWithRequestAndLogAndDelegate(
148 cache, trans_info, MockHttpRequest(trans_info), NULL, log, 172 cache, trans_info, MockHttpRequest(trans_info), NULL, log,
149 kNoDelegateTransactionCheck); 173 kNoDelegateTransactionCheck, kNoDelegateTransactionCheck);
150 } 174 }
151 175
152 void RunTransactionTestWithDelegate(net::HttpCache* cache, 176 void RunTransactionTestWithDelegate(net::HttpCache* cache,
153 const MockTransaction& trans_info, 177 const MockTransaction& trans_info,
154 int num_delegate_actions) { 178 int num_cache_delegate_actions,
179 int num_network_delegate_actions) {
155 RunTransactionTestWithRequestAndLogAndDelegate( 180 RunTransactionTestWithRequestAndLogAndDelegate(
156 cache, trans_info, MockHttpRequest(trans_info), NULL, net::BoundNetLog(), 181 cache, trans_info, MockHttpRequest(trans_info), NULL, net::BoundNetLog(),
157 num_delegate_actions); 182 num_cache_delegate_actions, num_network_delegate_actions);
158 } 183 }
159 184
160 void RunTransactionTest(net::HttpCache* cache, 185 void RunTransactionTest(net::HttpCache* cache,
161 const MockTransaction& trans_info) { 186 const MockTransaction& trans_info) {
162 RunTransactionTestWithLog(cache, trans_info, net::BoundNetLog()); 187 RunTransactionTestWithLog(cache, trans_info, net::BoundNetLog());
163 } 188 }
164 189
165 void RunTransactionTestWithResponseInfo(net::HttpCache* cache, 190 void RunTransactionTestWithResponseInfo(net::HttpCache* cache,
166 const MockTransaction& trans_info, 191 const MockTransaction& trans_info,
167 net::HttpResponseInfo* response) { 192 net::HttpResponseInfo* response) {
(...skipping 3730 matching lines...) Expand 10 before | Expand all | Expand 10 after
3898 3923
3899 MockTransaction transaction(kSimpleGET_Transaction); 3924 MockTransaction transaction(kSimpleGET_Transaction);
3900 transaction.response_headers = 3925 transaction.response_headers =
3901 "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n" 3926 "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
3902 "Content-Length: 22\n" 3927 "Content-Length: 22\n"
3903 "Etag: \"foopy\"\n"; 3928 "Etag: \"foopy\"\n";
3904 AddMockTransaction(&transaction); 3929 AddMockTransaction(&transaction);
3905 MockHttpRequest request(transaction); 3930 MockHttpRequest request(transaction);
3906 3931
3907 scoped_ptr<Context> c(new Context()); 3932 scoped_ptr<Context> c(new Context());
3908 int rv = cache.http_cache()->CreateTransaction(&c->trans, NULL); 3933 // We use a test delegate to ensure that after initiating destruction
3934 // of the transaction, no further delegate callbacks happen.
3935 // We initialize the TestHttpTransactionDelegate with the correct number of
3936 // cache actions and network actions to be reported.
3937 scoped_ptr<TestHttpTransactionDelegate> delegate(
3938 new TestHttpTransactionDelegate(7, 3));
3939 int rv = cache.http_cache()->CreateTransaction(&c->trans, delegate.get());
3909 EXPECT_EQ(net::OK, rv); 3940 EXPECT_EQ(net::OK, rv);
3910 3941
3911 rv = c->trans->Start(&request, c->callback.callback(), net::BoundNetLog()); 3942 rv = c->trans->Start(&request, c->callback.callback(), net::BoundNetLog());
3912 if (rv == net::ERR_IO_PENDING) 3943 if (rv == net::ERR_IO_PENDING)
3913 rv = c->callback.WaitForResult(); 3944 rv = c->callback.WaitForResult();
3914 3945
3915 EXPECT_EQ(1, cache.network_layer()->transaction_count()); 3946 EXPECT_EQ(1, cache.network_layer()->transaction_count());
3916 EXPECT_EQ(0, cache.disk_cache()->open_count()); 3947 EXPECT_EQ(0, cache.disk_cache()->open_count());
3917 EXPECT_EQ(1, cache.disk_cache()->create_count()); 3948 EXPECT_EQ(1, cache.disk_cache()->create_count());
3918 3949
3919 // Make sure that the entry has some data stored. 3950 // Make sure that the entry has some data stored.
3920 scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(10)); 3951 scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(10));
3921 rv = c->trans->Read(buf, buf->size(), c->callback.callback()); 3952 rv = c->trans->Read(buf, buf->size(), c->callback.callback());
3922 if (rv == net::ERR_IO_PENDING) 3953 if (rv == net::ERR_IO_PENDING)
3923 rv = c->callback.WaitForResult(); 3954 rv = c->callback.WaitForResult();
3924 EXPECT_EQ(buf->size(), rv); 3955 EXPECT_EQ(buf->size(), rv);
3925 3956
3926 // We want to cancel the request when the transaction is busy. 3957 // We want to cancel the request when the transaction is busy.
3927 rv = c->trans->Read(buf, buf->size(), c->callback.callback()); 3958 rv = c->trans->Read(buf, buf->size(), c->callback.callback());
3928 EXPECT_EQ(net::ERR_IO_PENDING, rv); 3959 EXPECT_EQ(net::ERR_IO_PENDING, rv);
3929 EXPECT_FALSE(c->callback.have_result()); 3960 EXPECT_FALSE(c->callback.have_result());
3930 3961
3931 MockHttpCache::SetTestMode(TEST_MODE_SYNC_ALL); 3962 MockHttpCache::SetTestMode(TEST_MODE_SYNC_ALL);
3932 3963
3933 // Destroy the transaction. 3964 // Destroy the transaction.
3934 c->trans.reset(); 3965 c->trans.reset();
3935 MockHttpCache::SetTestMode(0); 3966 MockHttpCache::SetTestMode(0);
3936 3967
3968 // Since the transaction was aborted in the middle of network I/O, we will
3969 // manually call the delegate so that its pending I/O operation will be
3970 // closed (which is what the test delegate is expecting).
3971 delegate->OnNetworkActionFinish();
rvargas (doing something else) 2012/08/17 22:05:00 It's better to have a way to explicitly check that
tburkard 2012/08/17 22:39:56 Done.
3972
3937 // Make sure that we don't invoke the callback. We may have an issue if the 3973 // Make sure that we don't invoke the callback. We may have an issue if the
3938 // UrlRequestJob is killed directly (without cancelling the UrlRequest) so we 3974 // UrlRequestJob is killed directly (without cancelling the UrlRequest) so we
3939 // could end up with the transaction being deleted twice if we send any 3975 // could end up with the transaction being deleted twice if we send any
3940 // notification from the transaction destructor (see http://crbug.com/31723). 3976 // notification from the transaction destructor (see http://crbug.com/31723).
3941 EXPECT_FALSE(c->callback.have_result()); 3977 EXPECT_FALSE(c->callback.have_result());
3942 3978
3943 // Verify that the entry is marked as incomplete. 3979 // Verify that the entry is marked as incomplete.
3944 disk_cache::Entry* entry; 3980 disk_cache::Entry* entry;
3945 ASSERT_TRUE(cache.OpenBackendEntry(kSimpleGET_Transaction.url, &entry)); 3981 ASSERT_TRUE(cache.OpenBackendEntry(kSimpleGET_Transaction.url, &entry));
3946 net::HttpResponseInfo response; 3982 net::HttpResponseInfo response;
(...skipping 1069 matching lines...) Expand 10 before | Expand all | Expand 10 after
5016 EXPECT_TRUE(truncated); 5052 EXPECT_TRUE(truncated);
5017 entry->Close(); 5053 entry->Close();
5018 } 5054 }
5019 5055
5020 TEST(HttpCache, SimpleGET_LoadOnlyFromCache_Hit_TransactionDelegate) { 5056 TEST(HttpCache, SimpleGET_LoadOnlyFromCache_Hit_TransactionDelegate) {
5021 MockHttpCache cache; 5057 MockHttpCache cache;
5022 5058
5023 // Write to the cache. 5059 // Write to the cache.
5024 RunTransactionTestWithDelegate(cache.http_cache(), 5060 RunTransactionTestWithDelegate(cache.http_cache(),
5025 kSimpleGET_Transaction, 5061 kSimpleGET_Transaction,
5026 8); 5062 8,
5063 3);
5027 5064
5028 // Force this transaction to read from the cache. 5065 // Force this transaction to read from the cache.
5029 MockTransaction transaction(kSimpleGET_Transaction); 5066 MockTransaction transaction(kSimpleGET_Transaction);
5030 transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE; 5067 transaction.load_flags |= net::LOAD_ONLY_FROM_CACHE;
5031 5068
5032 RunTransactionTestWithDelegate(cache.http_cache(), 5069 RunTransactionTestWithDelegate(cache.http_cache(),
5033 kSimpleGET_Transaction, 5070 kSimpleGET_Transaction,
5034 5); 5071 5,
5072 0);
5035 } 5073 }
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698