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 "content/renderer/dom_storage/dom_storage_cached_area.h" 6 7 #include <list> 8 9 #include "base/bind.h" 10 #include "base/strings/utf_string_conversions.h" 11 #include "content/renderer/dom_storage/dom_storage_proxy.h" 12 #include "testing/gtest/include/gtest/gtest.h" 13 14 namespace content { 15 16 namespace { 17 // A mock implementation of the DOMStorageProxy interface. 18 class MockProxy : public DOMStorageProxy { 19 public: 20 MockProxy() { 21 ResetObservations(); 22 } 23 24 // DOMStorageProxy interface for use by DOMStorageCachedArea. 25 26 virtual void LoadArea(int connection_id, 27 DOMStorageValuesMap* values, 28 bool* send_log_get_messages, 29 const CompletionCallback& callback) OVERRIDE { 30 pending_callbacks_.push_back(callback); 31 observed_load_area_ = true; 32 observed_connection_id_ = connection_id; 33 *values = load_area_return_values_; 34 *send_log_get_messages = false; 35 } 36 37 virtual void SetItem(int connection_id, 38 const base::string16& key, 39 const base::string16& value, 40 const GURL& page_url, 41 const CompletionCallback& callback) OVERRIDE { 42 pending_callbacks_.push_back(callback); 43 observed_set_item_ = true; 44 observed_connection_id_ = connection_id; 45 observed_key_ = key; 46 observed_value_ = value; 47 observed_page_url_ = page_url; 48 } 49 50 virtual void LogGetItem(int connection_id, 51 const base::string16& key, 52 const base::NullableString16& value) OVERRIDE { 53 } 54 55 virtual void RemoveItem(int connection_id, 56 const base::string16& key, 57 const GURL& page_url, 58 const CompletionCallback& callback) OVERRIDE { 59 pending_callbacks_.push_back(callback); 60 observed_remove_item_ = true; 61 observed_connection_id_ = connection_id; 62 observed_key_ = key; 63 observed_page_url_ = page_url; 64 } 65 66 virtual void ClearArea(int connection_id, 67 const GURL& page_url, 68 const CompletionCallback& callback) OVERRIDE { 69 pending_callbacks_.push_back(callback); 70 observed_clear_area_ = true; 71 observed_connection_id_ = connection_id; 72 observed_page_url_ = page_url; 73 } 74 75 // Methods and members for use by test fixtures. 76 77 void ResetObservations() { 78 observed_load_area_ = false; 79 observed_set_item_ = false; 80 observed_remove_item_ = false; 81 observed_clear_area_ = false; 82 observed_connection_id_ = 0; 83 observed_key_.clear(); 84 observed_value_.clear(); 85 observed_page_url_ = GURL(); 86 } 87 88 void CompleteAllPendingCallbacks() { 89 while (!pending_callbacks_.empty()) 90 CompleteOnePendingCallback(true); 91 } 92 93 void CompleteOnePendingCallback(bool success) { 94 ASSERT_TRUE(!pending_callbacks_.empty()); 95 pending_callbacks_.front().Run(success); 96 pending_callbacks_.pop_front(); 97 } 98 99 typedef std::list<CompletionCallback> CallbackList; 100 101 DOMStorageValuesMap load_area_return_values_; 102 CallbackList pending_callbacks_; 103 bool observed_load_area_; 104 bool observed_set_item_; 105 bool observed_remove_item_; 106 bool observed_clear_area_; 107 int observed_connection_id_; 108 base::string16 observed_key_; 109 base::string16 observed_value_; 110 GURL observed_page_url_; 111 112 private: 113 virtual ~MockProxy() {} 114 }; 115 116 } // namespace 117 118 class DOMStorageCachedAreaTest : public testing::Test { 119 public: 120 DOMStorageCachedAreaTest() 121 : kNamespaceId(10), 122 kOrigin("http://dom_storage/"), 123 kKey(base::ASCIIToUTF16("key")), 124 kValue(base::ASCIIToUTF16("value")), 125 kPageUrl("http://dom_storage/page") { 126 } 127 128 const int64 kNamespaceId; 129 const GURL kOrigin; 130 const base::string16 kKey; 131 const base::string16 kValue; 132 const GURL kPageUrl; 133 134 virtual void SetUp() { 135 mock_proxy_ = new MockProxy(); 136 } 137 138 bool IsPrimed(DOMStorageCachedArea* cached_area) { 139 return cached_area->map_.get(); 140 } 141 142 bool IsIgnoringAllMutations(DOMStorageCachedArea* cached_area) { 143 return cached_area->ignore_all_mutations_; 144 } 145 146 bool IsIgnoringKeyMutations(DOMStorageCachedArea* cached_area, 147 const base::string16& key) { 148 return cached_area->should_ignore_key_mutation(key); 149 } 150 151 void ResetAll(DOMStorageCachedArea* cached_area) { 152 cached_area->Reset(); 153 mock_proxy_->ResetObservations(); 154 mock_proxy_->pending_callbacks_.clear(); 155 } 156 157 void ResetCacheOnly(DOMStorageCachedArea* cached_area) { 158 cached_area->Reset(); 159 } 160 161 protected: 162 scoped_refptr<MockProxy> mock_proxy_; 163 }; 164 165 TEST_F(DOMStorageCachedAreaTest, Basics) { 166 EXPECT_TRUE(mock_proxy_->HasOneRef()); 167 scoped_refptr<DOMStorageCachedArea> cached_area = 168 new DOMStorageCachedArea(kNamespaceId, kOrigin, mock_proxy_.get()); 169 EXPECT_EQ(kNamespaceId, cached_area->namespace_id()); 170 EXPECT_EQ(kOrigin, cached_area->origin()); 171 EXPECT_FALSE(mock_proxy_->HasOneRef()); 172 cached_area->ApplyMutation(base::NullableString16(kKey, false), 173 base::NullableString16(kValue, false)); 174 EXPECT_FALSE(IsPrimed(cached_area.get())); 175 176 ResetAll(cached_area.get()); 177 EXPECT_EQ(kNamespaceId, cached_area->namespace_id()); 178 EXPECT_EQ(kOrigin, cached_area->origin()); 179 180 const int kConnectionId = 1; 181 EXPECT_EQ(0u, cached_area->GetLength(kConnectionId)); 182 EXPECT_TRUE(cached_area->SetItem(kConnectionId, kKey, kValue, kPageUrl)); 183 EXPECT_EQ(1u, cached_area->GetLength(kConnectionId)); 184 EXPECT_EQ(kKey, cached_area->GetKey(kConnectionId, 0).string()); 185 EXPECT_EQ(kValue, cached_area->GetItem(kConnectionId, kKey).string()); 186 cached_area->RemoveItem(kConnectionId, kKey, kPageUrl); 187 EXPECT_EQ(0u, cached_area->GetLength(kConnectionId)); 188 } 189 190 TEST_F(DOMStorageCachedAreaTest, Getters) { 191 const int kConnectionId = 7; 192 scoped_refptr<DOMStorageCachedArea> cached_area = 193 new DOMStorageCachedArea(kNamespaceId, kOrigin, mock_proxy_.get()); 194 195 // GetLength, we expect to see one call to load in the proxy. 196 EXPECT_FALSE(IsPrimed(cached_area.get())); 197 EXPECT_EQ(0u, cached_area->GetLength(kConnectionId)); 198 EXPECT_TRUE(IsPrimed(cached_area.get())); 199 EXPECT_TRUE(mock_proxy_->observed_load_area_); 200 EXPECT_EQ(kConnectionId, mock_proxy_->observed_connection_id_); 201 EXPECT_EQ(1u, mock_proxy_->pending_callbacks_.size()); 202 EXPECT_TRUE(IsIgnoringAllMutations(cached_area.get())); 203 mock_proxy_->CompleteAllPendingCallbacks(); 204 EXPECT_FALSE(IsIgnoringAllMutations(cached_area.get())); 205 206 // GetKey, expect the one call to load. 207 ResetAll(cached_area.get()); 208 EXPECT_FALSE(IsPrimed(cached_area.get())); 209 EXPECT_TRUE(cached_area->GetKey(kConnectionId, 2).is_null()); 210 EXPECT_TRUE(IsPrimed(cached_area.get())); 211 EXPECT_TRUE(mock_proxy_->observed_load_area_); 212 EXPECT_EQ(kConnectionId, mock_proxy_->observed_connection_id_); 213 EXPECT_EQ(1u, mock_proxy_->pending_callbacks_.size()); 214 215 // GetItem, ditto. 216 ResetAll(cached_area.get()); 217 EXPECT_FALSE(IsPrimed(cached_area.get())); 218 EXPECT_TRUE(cached_area->GetItem(kConnectionId, kKey).is_null()); 219 EXPECT_TRUE(IsPrimed(cached_area.get())); 220 EXPECT_TRUE(mock_proxy_->observed_load_area_); 221 EXPECT_EQ(kConnectionId, mock_proxy_->observed_connection_id_); 222 EXPECT_EQ(1u, mock_proxy_->pending_callbacks_.size()); 223 } 224 225 TEST_F(DOMStorageCachedAreaTest, Setters) { 226 const int kConnectionId = 7; 227 scoped_refptr<DOMStorageCachedArea> cached_area = 228 new DOMStorageCachedArea(kNamespaceId, kOrigin, mock_proxy_.get()); 229 230 // SetItem, we expect a call to load followed by a call to set item 231 // in the proxy. 232 EXPECT_FALSE(IsPrimed(cached_area.get())); 233 EXPECT_TRUE(cached_area->SetItem(kConnectionId, kKey, kValue, kPageUrl)); 234 EXPECT_TRUE(IsPrimed(cached_area.get())); 235 EXPECT_TRUE(mock_proxy_->observed_load_area_); 236 EXPECT_TRUE(mock_proxy_->observed_set_item_); 237 EXPECT_EQ(kConnectionId, mock_proxy_->observed_connection_id_); 238 EXPECT_EQ(kPageUrl, mock_proxy_->observed_page_url_); 239 EXPECT_EQ(kKey, mock_proxy_->observed_key_); 240 EXPECT_EQ(kValue, mock_proxy_->observed_value_); 241 EXPECT_EQ(2u, mock_proxy_->pending_callbacks_.size()); 242 243 // Clear, we expect a just the one call to clear in the proxy since 244 // there's no need to load the data prior to deleting it. 245 ResetAll(cached_area.get()); 246 EXPECT_FALSE(IsPrimed(cached_area.get())); 247 cached_area->Clear(kConnectionId, kPageUrl); 248 EXPECT_TRUE(IsPrimed(cached_area.get())); 249 EXPECT_TRUE(mock_proxy_->observed_clear_area_); 250 EXPECT_EQ(kConnectionId, mock_proxy_->observed_connection_id_); 251 EXPECT_EQ(kPageUrl, mock_proxy_->observed_page_url_); 252 EXPECT_EQ(1u, mock_proxy_->pending_callbacks_.size()); 253 254 // RemoveItem with nothing to remove, expect just one call to load. 255 ResetAll(cached_area.get()); 256 EXPECT_FALSE(IsPrimed(cached_area.get())); 257 cached_area->RemoveItem(kConnectionId, kKey, kPageUrl); 258 EXPECT_TRUE(IsPrimed(cached_area.get())); 259 EXPECT_TRUE(mock_proxy_->observed_load_area_); 260 EXPECT_FALSE(mock_proxy_->observed_remove_item_); 261 EXPECT_EQ(kConnectionId, mock_proxy_->observed_connection_id_); 262 EXPECT_EQ(1u, mock_proxy_->pending_callbacks_.size()); 263 264 // RemoveItem with something to remove, expect a call to load followed 265 // by a call to remove. 266 ResetAll(cached_area.get()); 267 mock_proxy_->load_area_return_values_[kKey] = 268 base::NullableString16(kValue, false); 269 EXPECT_FALSE(IsPrimed(cached_area.get())); 270 cached_area->RemoveItem(kConnectionId, kKey, kPageUrl); 271 EXPECT_TRUE(IsPrimed(cached_area.get())); 272 EXPECT_TRUE(mock_proxy_->observed_load_area_); 273 EXPECT_TRUE(mock_proxy_->observed_remove_item_); 274 EXPECT_EQ(kConnectionId, mock_proxy_->observed_connection_id_); 275 EXPECT_EQ(kPageUrl, mock_proxy_->observed_page_url_); 276 EXPECT_EQ(kKey, mock_proxy_->observed_key_); 277 EXPECT_EQ(2u, mock_proxy_->pending_callbacks_.size()); 278 } 279 280 TEST_F(DOMStorageCachedAreaTest, MutationsAreIgnoredUntilLoadCompletion) { 281 const int kConnectionId = 7; 282 scoped_refptr<DOMStorageCachedArea> cached_area = 283 new DOMStorageCachedArea(kNamespaceId, kOrigin, mock_proxy_.get()); 284 EXPECT_TRUE(cached_area->GetItem(kConnectionId, kKey).is_null()); 285 EXPECT_TRUE(IsPrimed(cached_area.get())); 286 EXPECT_TRUE(IsIgnoringAllMutations(cached_area.get())); 287 288 // Before load completion, the mutation should be ignored. 289 cached_area->ApplyMutation(base::NullableString16(kKey, false), 290 base::NullableString16(kValue, false)); 291 EXPECT_TRUE(cached_area->GetItem(kConnectionId, kKey).is_null()); 292 293 // Call the load completion callback. 294 mock_proxy_->CompleteOnePendingCallback(true); 295 EXPECT_FALSE(IsIgnoringAllMutations(cached_area.get())); 296 297 // Verify that mutations are now applied. 298 cached_area->ApplyMutation(base::NullableString16(kKey, false), 299 base::NullableString16(kValue, false)); 300 EXPECT_EQ(kValue, cached_area->GetItem(kConnectionId, kKey).string()); 301 } 302 303 TEST_F(DOMStorageCachedAreaTest, MutationsAreIgnoredUntilClearCompletion) { 304 const int kConnectionId = 4; 305 scoped_refptr<DOMStorageCachedArea> cached_area = 306 new DOMStorageCachedArea(kNamespaceId, kOrigin, mock_proxy_.get()); 307 cached_area->Clear(kConnectionId, kPageUrl); 308 EXPECT_TRUE(IsIgnoringAllMutations(cached_area.get())); 309 mock_proxy_->CompleteOnePendingCallback(true); 310 EXPECT_FALSE(IsIgnoringAllMutations(cached_area.get())); 311 312 // Verify that calling Clear twice works as expected, the first 313 // completion callback should have been cancelled. 314 ResetCacheOnly(cached_area.get()); 315 cached_area->Clear(kConnectionId, kPageUrl); 316 EXPECT_TRUE(IsIgnoringAllMutations(cached_area.get())); 317 cached_area->Clear(kConnectionId, kPageUrl); 318 EXPECT_TRUE(IsIgnoringAllMutations(cached_area.get())); 319 mock_proxy_->CompleteOnePendingCallback(true); 320 EXPECT_TRUE(IsIgnoringAllMutations(cached_area.get())); 321 mock_proxy_->CompleteOnePendingCallback(true); 322 EXPECT_FALSE(IsIgnoringAllMutations(cached_area.get())); 323 } 324 325 TEST_F(DOMStorageCachedAreaTest, KeyMutationsAreIgnoredUntilCompletion) { 326 const int kConnectionId = 8; 327 scoped_refptr<DOMStorageCachedArea> cached_area = 328 new DOMStorageCachedArea(kNamespaceId, kOrigin, mock_proxy_.get()); 329 330 // SetItem 331 EXPECT_TRUE(cached_area->SetItem(kConnectionId, kKey, kValue, kPageUrl)); 332 mock_proxy_->CompleteOnePendingCallback(true); // load completion 333 EXPECT_FALSE(IsIgnoringAllMutations(cached_area.get())); 334 EXPECT_TRUE(IsIgnoringKeyMutations(cached_area.get(), kKey)); 335 cached_area->ApplyMutation(base::NullableString16(kKey, false), 336 base::NullableString16()); 337 EXPECT_EQ(kValue, cached_area->GetItem(kConnectionId, kKey).string()); 338 mock_proxy_->CompleteOnePendingCallback(true); // set completion 339 EXPECT_FALSE(IsIgnoringKeyMutations(cached_area.get(), kKey)); 340 341 // RemoveItem 342 cached_area->RemoveItem(kConnectionId, kKey, kPageUrl); 343 EXPECT_TRUE(IsIgnoringKeyMutations(cached_area.get(), kKey)); 344 mock_proxy_->CompleteOnePendingCallback(true); // remove completion 345 EXPECT_FALSE(IsIgnoringKeyMutations(cached_area.get(), kKey)); 346 347 // Multiple mutations to the same key. 348 EXPECT_TRUE(cached_area->SetItem(kConnectionId, kKey, kValue, kPageUrl)); 349 cached_area->RemoveItem(kConnectionId, kKey, kPageUrl); 350 EXPECT_TRUE(IsIgnoringKeyMutations(cached_area.get(), kKey)); 351 mock_proxy_->CompleteOnePendingCallback(true); // set completion 352 EXPECT_TRUE(IsIgnoringKeyMutations(cached_area.get(), kKey)); 353 mock_proxy_->CompleteOnePendingCallback(true); // remove completion 354 EXPECT_FALSE(IsIgnoringKeyMutations(cached_area.get(), kKey)); 355 356 // A failed set item operation should Reset the cache. 357 EXPECT_TRUE(cached_area->SetItem(kConnectionId, kKey, kValue, kPageUrl)); 358 EXPECT_TRUE(IsIgnoringKeyMutations(cached_area.get(), kKey)); 359 mock_proxy_->CompleteOnePendingCallback(false); 360 EXPECT_FALSE(IsPrimed(cached_area.get())); 361 } 362 363 } // namespace content 364
