Clear in-memory caches of renderers when rules change

chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry_unittest.cc

 // Copyright (c) 2012 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.
 
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry.h"
 
 #include <vector>
 
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop.h"
@@ skipping 16 matching lines @@
 }  // namespace
 
 namespace extensions {
 
 namespace helpers = extension_web_request_api_helpers;
 namespace keys = declarative_webrequest_constants;
 namespace keys2 = url_matcher_constants;
 
 class TestWebRequestRulesRegistry : public WebRequestRulesRegistry {
  public:
-  TestWebRequestRulesRegistry() : WebRequestRulesRegistry(NULL, NULL) {}
+  TestWebRequestRulesRegistry()
+      : WebRequestRulesRegistry(NULL, NULL),
+        num_clear_cache_calls_(0) {}
+
+  // Returns how often the in-memory caches of the renderers were instructed
+  // to be cleared.
+  int num_clear_cache_calls() const { return num_clear_cache_calls_; }
 
  protected:
   virtual ~TestWebRequestRulesRegistry() {}
 
   virtual base::Time GetExtensionInstallationTime(
       const std::string& extension_id) const {
     if (extension_id == kExtensionId)
       return base::Time() + base::TimeDelta::FromDays(1);
     else if (extension_id == kExtensionId2)
       return base::Time() + base::TimeDelta::FromDays(2);
     else
       return base::Time();
   }
+
+  virtual void ClearCacheOnNavigation() {
+    ++num_clear_cache_calls_;
+  }
+
+ private:
+  int num_clear_cache_calls_;
 };
 
 class WebRequestRulesRegistryTest : public testing::Test {
  public:
   WebRequestRulesRegistryTest()
       : message_loop(MessageLoop::TYPE_IO),
         ui(content::BrowserThread::UI, &message_loop),
         io(content::BrowserThread::IO, &message_loop) {}
 
   virtual ~WebRequestRulesRegistryTest() {}
@@ skipping 131 matching lines @@
     return rule;
   }
 
  protected:
   MessageLoop message_loop;
   content::TestBrowserThread ui;
   content::TestBrowserThread io;
 };
 
 TEST_F(WebRequestRulesRegistryTest, AddRulesImpl) {
-  scoped_refptr<WebRequestRulesRegistry> registry(
+  scoped_refptr<TestWebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry());
   std::string error;
 
   std::vector<linked_ptr<RulesRegistry::Rule> > rules;
   rules.push_back(CreateRule1());
   rules.push_back(CreateRule2());
 
   error = registry->AddRules(kExtensionId, rules);
   EXPECT_EQ("", error);
+  EXPECT_EQ(1, registry->num_clear_cache_calls());
 
   std::set<WebRequestRule::GlobalRuleId> matches;
 
   GURL http_url("http://www.example.com");
   TestURLRequestContext context;
   TestURLRequest http_request(http_url, NULL, &context);
   matches = registry->GetMatches(
       WebRequestRule::RequestData(&http_request, ON_BEFORE_REQUEST));
   EXPECT_EQ(2u, matches.size());
   EXPECT_TRUE(matches.find(std::make_pair(kExtensionId, kRuleId1)) !=
       matches.end());
   EXPECT_TRUE(matches.find(std::make_pair(kExtensionId, kRuleId2)) !=
       matches.end());
 
   GURL foobar_url("http://www.foobar.com");
   TestURLRequest foobar_request(foobar_url, NULL, &context);
   matches = registry->GetMatches(
       WebRequestRule::RequestData(&foobar_request, ON_BEFORE_REQUEST));
   EXPECT_EQ(1u, matches.size());
   EXPECT_TRUE(matches.find(std::make_pair(kExtensionId, kRuleId2)) !=
       matches.end());
 }
 
 TEST_F(WebRequestRulesRegistryTest, RemoveRulesImpl) {
-  scoped_refptr<WebRequestRulesRegistry> registry(
+  scoped_refptr<TestWebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry());
   std::string error;
 
   // Setup RulesRegistry to contain two rules.
   std::vector<linked_ptr<RulesRegistry::Rule> > rules_to_add;
   rules_to_add.push_back(CreateRule1());
   rules_to_add.push_back(CreateRule2());
   error = registry->AddRules(kExtensionId, rules_to_add);
   EXPECT_EQ("", error);
+  EXPECT_EQ(1, registry->num_clear_cache_calls());
 
   // Verify initial state.
   std::vector<linked_ptr<RulesRegistry::Rule> > registered_rules;
   registry->GetAllRules(kExtensionId, &registered_rules);
   EXPECT_EQ(2u, registered_rules.size());
 
   // Remove first rule.
   std::vector<std::string> rules_to_remove;
   rules_to_remove.push_back(kRuleId1);
   error = registry->RemoveRules(kExtensionId, rules_to_remove);
   EXPECT_EQ("", error);
+  EXPECT_EQ(2, registry->num_clear_cache_calls());
 
   // Verify that only one rule is left.
   registered_rules.clear();
   registry->GetAllRules(kExtensionId, &registered_rules);
   EXPECT_EQ(1u, registered_rules.size());
 
   // Now rules_to_remove contains both rules, i.e. one that does not exist in
   // the rules registry anymore. Effectively we only remove the second rule.
   rules_to_remove.push_back(kRuleId2);
   error = registry->RemoveRules(kExtensionId, rules_to_remove);
   EXPECT_EQ("", error);
+  EXPECT_EQ(3, registry->num_clear_cache_calls());
 
   // Verify that everything is gone.
   registered_rules.clear();
   registry->GetAllRules(kExtensionId, &registered_rules);
   EXPECT_EQ(0u, registered_rules.size());
 
   EXPECT_TRUE(registry->IsEmpty());
 }
 
 TEST_F(WebRequestRulesRegistryTest, RemoveAllRulesImpl) {
-  scoped_refptr<WebRequestRulesRegistry> registry(
+  scoped_refptr<TestWebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry());
   std::string error;
 
   // Setup RulesRegistry to contain two rules, one for each extension.
   std::vector<linked_ptr<RulesRegistry::Rule> > rules_to_add(1);
   rules_to_add[0] = CreateRule1();
   error = registry->AddRules(kExtensionId, rules_to_add);
   EXPECT_EQ("", error);
+  EXPECT_EQ(1, registry->num_clear_cache_calls());
 
   rules_to_add[0] = CreateRule2();
   error = registry->AddRules(kExtensionId2, rules_to_add);
   EXPECT_EQ("", error);
+  EXPECT_EQ(2, registry->num_clear_cache_calls());
 
   // Verify initial state.
   std::vector<linked_ptr<RulesRegistry::Rule> > registered_rules;
   registry->GetAllRules(kExtensionId, &registered_rules);
   EXPECT_EQ(1u, registered_rules.size());
   registered_rules.clear();
   registry->GetAllRules(kExtensionId2, &registered_rules);
   EXPECT_EQ(1u, registered_rules.size());
 
   // Remove rule of first extension.
   error = registry->RemoveAllRules(kExtensionId);
   EXPECT_EQ("", error);
+  EXPECT_EQ(3, registry->num_clear_cache_calls());
 
   // Verify that only the first rule is deleted.
   registered_rules.clear();
   registry->GetAllRules(kExtensionId, &registered_rules);
   EXPECT_EQ(0u, registered_rules.size());
   registered_rules.clear();
   registry->GetAllRules(kExtensionId2, &registered_rules);
   EXPECT_EQ(1u, registered_rules.size());
 
   // Test removing rules if none exist.
   error = registry->RemoveAllRules(kExtensionId);
   EXPECT_EQ("", error);
+  EXPECT_EQ(4, registry->num_clear_cache_calls());
 
   // Remove rule from second extension.
   error = registry->RemoveAllRules(kExtensionId2);
   EXPECT_EQ("", error);
+  EXPECT_EQ(5, registry->num_clear_cache_calls());
 
   EXPECT_TRUE(registry->IsEmpty());
 }
 
 // Test precedences between extensions.
 TEST_F(WebRequestRulesRegistryTest, Precedences) {
   scoped_refptr<WebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry());
   std::string error;
 
@@ skipping 69 matching lines @@
   // The redirect by the first extension is ignored due to the ignore rule.
   ASSERT_EQ(1u, deltas.size());
   LinkedPtrEventResponseDelta effective_rule = *(deltas.begin());
 
   EXPECT_EQ(kExtensionId2, effective_rule->extension_id);
   EXPECT_EQ(base::Time() + base::TimeDelta::FromDays(2),
             effective_rule->extension_install_time);
   EXPECT_EQ(GURL("http://www.bar.com"), effective_rule->new_url);
 }
 }  // namespace extensions