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 "base/bind.h" 6 #include "base/bind_helpers.h" 7 #include "base/command_line.h" 8 #include "base/memory/scoped_ptr.h" 9 #include "base/strings/stringprintf.h" 10 #include "base/strings/utf_string_conversions.h" 11 #include "base/test/thread_test_helper.h" 12 #include "chrome/browser/extensions/extension_apitest.h" 13 #include "chrome/browser/extensions/test_extension_dir.h" 14 #include "chrome/browser/ui/browser.h" 15 #include "chrome/browser/ui/tabs/tab_strip_model.h" 16 #include "chrome/test/base/ui_test_utils.h" 17 #include "content/public/browser/browser_thread.h" 18 #include "extensions/browser/api/declarative/rules_registry_service.h" 19 #include "extensions/browser/api/declarative_webrequest/webrequest_constants.h" 20 #include "extensions/browser/api/declarative_webrequest/webrequest_rules_registry.h" 21 #include "extensions/browser/extension_prefs.h" 22 #include "extensions/common/extension.h" 23 #include "extensions/test/extension_test_message_listener.h" 24 25 using content::BrowserThread; 26 using extensions::Extension; 27 using extensions::ExtensionPrefs; 28 using extensions::RulesRegistry; 29 using extensions::RulesRegistryService; 30 using extensions::TestExtensionDir; 31 using extensions::WebRequestRulesRegistry; 32 33 namespace { 34 35 const char kArbitraryUrl[] = "http://www.example.com"; // Must be http://. 36 37 // The extension in "declarative/redirect_to_data" redirects every navigation to 38 // a page with title |kTestTitle|. 39 #define TEST_TITLE_STRING ":TEST:" 40 const char kTestTitle[] = TEST_TITLE_STRING; 41 42 // All methods and constands below containing "RedirectToData" in their names 43 // are parts of a test extension "Redirect to 'data:'". 44 std::string GetRedirectToDataManifestWithVersion(unsigned version) { 45 return base::StringPrintf( 46 "{\n" 47 " \"name\": \"Redirect to 'data:' (declarative apitest)\",\n" 48 " \"version\": \"%d\",\n" 49 " \"manifest_version\": 2,\n" 50 " \"description\": \"Redirects all requests to a fixed data: URI.\",\n" 51 " \"background\": {\n" 52 " \"scripts\": [\"background.js\"]\n" 53 " },\n" 54 " \"permissions\": [\n" 55 " \"declarativeWebRequest\", \"<all_urls>\"\n" 56 " ]\n" 57 "}\n", 58 version); 59 } 60 61 const char kRedirectToDataConstants[] = 62 "var redirectDataURI =\n" 63 " 'data:text/html;charset=utf-8,<html><head><title>' +\n" 64 " '" TEST_TITLE_STRING "' +\n" 65 " '<%2Ftitle><%2Fhtml>';\n"; 66 #undef TEST_TITLE_STRING 67 68 const char kRedirectToDataRules[] = 69 "var rules = [{\n" 70 " conditions: [\n" 71 " new chrome.declarativeWebRequest.RequestMatcher({\n" 72 " url: {schemes: ['http']}})\n" 73 " ],\n" 74 " actions: [\n" 75 " new chrome.declarativeWebRequest.RedirectRequest({\n" 76 " redirectUrl: redirectDataURI\n" 77 " })\n" 78 " ]\n" 79 "}];\n"; 80 81 const char kRedirectToDataInstallRules[] = 82 "function report(details) {\n" 83 " if (chrome.extension.lastError) {\n" 84 " chrome.test.log(chrome.extension.lastError.message);\n" 85 " } else {\n" 86 " chrome.test.sendMessage(\"ready\", function(reply) {})\n" 87 " }\n" 88 "}\n" 89 "\n" 90 "chrome.runtime.onInstalled.addListener(function(details) {\n" 91 " if (details.reason == 'install')\n" 92 " chrome.declarativeWebRequest.onRequest.addRules(rules, report);\n" 93 "});\n"; 94 95 const char kRedirectToDataNoRules[] = 96 "chrome.runtime.onInstalled.addListener(function(details) {\n" 97 " chrome.test.sendMessage(\"ready\", function(reply) {})\n" 98 "});\n"; 99 100 } // namespace 101 102 class DeclarativeApiTest : public ExtensionApiTest { 103 public: 104 std::string GetTitle() { 105 base::string16 title( 106 browser()->tab_strip_model()->GetActiveWebContents()->GetTitle()); 107 return base::UTF16ToUTF8(title); 108 } 109 110 // Reports the number of rules registered for the |extension_id| with the 111 // non-webview rules registry. 112 size_t NumberOfRegisteredRules(const std::string& extension_id) { 113 RulesRegistryService* rules_registry_service = 114 extensions::RulesRegistryService::Get(browser()->profile()); 115 scoped_refptr<RulesRegistry> rules_registry = 116 rules_registry_service->GetRulesRegistry( 117 RulesRegistry::WebViewKey(0, 0), 118 extensions::declarative_webrequest_constants::kOnRequest); 119 std::vector<linked_ptr<RulesRegistry::Rule> > rules; 120 BrowserThread::PostTask( 121 BrowserThread::IO, 122 FROM_HERE, 123 base::Bind( 124 &RulesRegistry::GetAllRules, rules_registry, extension_id, &rules)); 125 scoped_refptr<base::ThreadTestHelper> io_helper(new base::ThreadTestHelper( 126 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO).get())); 127 EXPECT_TRUE(io_helper->Run()); 128 return rules.size(); 129 } 130 }; 131 132 IN_PROC_BROWSER_TEST_F(DeclarativeApiTest, DeclarativeApi) { 133 ASSERT_TRUE(RunExtensionTest("declarative/api")) << message_; 134 135 // Check that uninstalling the extension has removed all rules. 136 std::string extension_id = GetSingleLoadedExtension()->id(); 137 UninstallExtension(extension_id); 138 139 // UnloadExtension posts a task to the owner thread of the extension 140 // to process this unloading. The next task to retrive all rules 141 // is therefore processed after the UnloadExtension task has been executed. 142 EXPECT_EQ(0u, NumberOfRegisteredRules(extension_id)); 143 } 144 145 // PersistRules test first installs an extension, which registers some rules. 146 // Then after browser restart, it checks that the rules are still in effect. 147 IN_PROC_BROWSER_TEST_F(DeclarativeApiTest, PRE_PersistRules) { 148 // Note that we cannot use an extension generated by *GetRedirectToData* 149 // helpers in a TestExtensionDir, because we need the extension to persist 150 // until the PersistRules test is run. 151 ASSERT_TRUE(RunExtensionTest("declarative/redirect_to_data")) << message_; 152 } 153 154 IN_PROC_BROWSER_TEST_F(DeclarativeApiTest, PersistRules) { 155 ui_test_utils::NavigateToURL(browser(), GURL(kArbitraryUrl)); 156 EXPECT_EQ(kTestTitle, GetTitle()); 157 } 158 159 // Test that the rules are correctly persisted and (de)activated during 160 // changing the "installed" and "enabled" status of an extension. 161 IN_PROC_BROWSER_TEST_F(DeclarativeApiTest, ExtensionLifetimeRulesHandling) { 162 TestExtensionDir ext_dir; 163 164 // 1. Install the extension. Rules should become active. 165 ext_dir.WriteManifest(GetRedirectToDataManifestWithVersion(1)); 166 ext_dir.WriteFile(FILE_PATH_LITERAL("background.js"), 167 base::StringPrintf("%s%s%s", 168 kRedirectToDataConstants, 169 kRedirectToDataRules, 170 kRedirectToDataInstallRules)); 171 ExtensionTestMessageListener ready("ready", /*will_reply=*/false); 172 const Extension* extension = InstallExtensionWithUIAutoConfirm( 173 ext_dir.Pack(), 1 /*+1 installed extension*/, browser()); 174 ASSERT_TRUE(extension); 175 std::string extension_id(extension->id()); 176 ASSERT_TRUE(ready.WaitUntilSatisfied()); 177 ui_test_utils::NavigateToURL(browser(), GURL(kArbitraryUrl)); 178 EXPECT_EQ(kTestTitle, GetTitle()); 179 EXPECT_EQ(1u, NumberOfRegisteredRules(extension_id)); 180 181 // 2. Disable the extension. Rules are no longer active, but are still 182 // registered. 183 DisableExtension(extension_id); 184 ui_test_utils::NavigateToURL(browser(), GURL(kArbitraryUrl)); 185 EXPECT_NE(kTestTitle, GetTitle()); 186 EXPECT_EQ(1u, NumberOfRegisteredRules(extension_id)); 187 188 // 3. Enable the extension again. Rules are active again. 189 EnableExtension(extension_id); 190 ui_test_utils::NavigateToURL(browser(), GURL(kArbitraryUrl)); 191 EXPECT_EQ(kTestTitle, GetTitle()); 192 EXPECT_EQ(1u, NumberOfRegisteredRules(extension_id)); 193 194 // 4. Bump the version and update, without the code to add the rules. Rules 195 // are still active, because the registry does not drop them unless the 196 // extension gets uninstalled. 197 ext_dir.WriteManifest(GetRedirectToDataManifestWithVersion(2)); 198 ext_dir.WriteFile( 199 FILE_PATH_LITERAL("background.js"), 200 base::StringPrintf( 201 "%s%s", kRedirectToDataConstants, kRedirectToDataNoRules)); 202 ExtensionTestMessageListener ready_after_update("ready", 203 /*will_reply=*/false); 204 EXPECT_TRUE(UpdateExtension( 205 extension_id, ext_dir.Pack(), 0 /*no new installed extension*/)); 206 ASSERT_TRUE(ready_after_update.WaitUntilSatisfied()); 207 ui_test_utils::NavigateToURL(browser(), GURL(kArbitraryUrl)); 208 EXPECT_EQ(kTestTitle, GetTitle()); 209 EXPECT_EQ(1u, NumberOfRegisteredRules(extension_id)); 210 211 // 5. Reload the extension. Rules remain active. 212 ReloadExtension(extension_id); 213 ui_test_utils::NavigateToURL(browser(), GURL(kArbitraryUrl)); 214 EXPECT_EQ(kTestTitle, GetTitle()); 215 EXPECT_EQ(1u, NumberOfRegisteredRules(extension_id)); 216 217 // 6. Uninstall the extension. Rules are gone. 218 UninstallExtension(extension_id); 219 ui_test_utils::NavigateToURL(browser(), GURL(kArbitraryUrl)); 220 EXPECT_NE(kTestTitle, GetTitle()); 221 EXPECT_EQ(0u, NumberOfRegisteredRules(extension_id)); 222 } 223 224 // When an extenion is uninstalled, the state store deletes all preferences 225 // stored for that extension. We need to make sure we don't store anything after 226 // that deletion occurs. 227 IN_PROC_BROWSER_TEST_F(DeclarativeApiTest, NoTracesAfterUninstalling) { 228 TestExtensionDir ext_dir; 229 230 // 1. Install the extension. Verify that rules become active and some prefs 231 // are stored. 232 ext_dir.WriteManifest(GetRedirectToDataManifestWithVersion(1)); 233 ext_dir.WriteFile(FILE_PATH_LITERAL("background.js"), 234 base::StringPrintf("%s%s%s", 235 kRedirectToDataConstants, 236 kRedirectToDataRules, 237 kRedirectToDataInstallRules)); 238 ExtensionTestMessageListener ready("ready", /*will_reply=*/false); 239 const Extension* extension = InstallExtensionWithUIAutoConfirm( 240 ext_dir.Pack(), 1 /*+1 installed extension*/, browser()); 241 ASSERT_TRUE(extension); 242 std::string extension_id(extension->id()); 243 ASSERT_TRUE(ready.WaitUntilSatisfied()); 244 ui_test_utils::NavigateToURL(browser(), GURL(kArbitraryUrl)); 245 EXPECT_EQ(kTestTitle, GetTitle()); 246 EXPECT_EQ(1u, NumberOfRegisteredRules(extension_id)); 247 ExtensionPrefs* extension_prefs = ExtensionPrefs::Get(browser()->profile()); 248 EXPECT_TRUE(extension_prefs->HasPrefForExtension(extension_id)); 249 250 // 2. Uninstall the extension. Rules are gone and preferences should be empty. 251 UninstallExtension(extension_id); 252 ui_test_utils::NavigateToURL(browser(), GURL(kArbitraryUrl)); 253 EXPECT_NE(kTestTitle, GetTitle()); 254 EXPECT_EQ(0u, NumberOfRegisteredRules(extension_id)); 255 EXPECT_FALSE(extension_prefs->HasPrefForExtension(extension_id)); 256 } 257
