| // Copyright 2024 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "base/strings/stringprintf.h" |
| #include "base/threading/thread_restrictions.h" |
| #include "chrome/browser/extensions/chrome_test_extension_loader.h" |
| #include "chrome/browser/ui/android/tab_model/tab_model_list.h" |
| #include "chrome/test/base/android/android_browser_test.h" |
| #include "chrome/test/base/chrome_test_utils.h" |
| #include "content/public/browser/web_contents.h" |
| #include "content/public/test/browser_test.h" |
| #include "content/public/test/browser_test_utils.h" |
| #include "extensions/browser/api/declarative_net_request/rules_monitor_service.h" |
| #include "extensions/browser/api/declarative_net_request/test_utils.h" |
| #include "extensions/browser/embedder_user_script_loader.h" |
| #include "extensions/browser/extension_registry.h" |
| #include "extensions/browser/extension_system.h" |
| #include "extensions/browser/user_script_manager.h" |
| #include "extensions/common/extension.h" |
| #include "extensions/common/file_util.h" |
| #include "extensions/common/manifest_handlers/content_scripts_handler.h" |
| #include "extensions/test/extension_test_message_listener.h" |
| #include "extensions/test/result_catcher.h" |
| #include "extensions/test/test_content_script_load_waiter.h" |
| #include "extensions/test/test_extension_dir.h" |
| #include "net/dns/mock_host_resolver.h" |
| |
| namespace extensions { |
| |
| // Smoke tests for the experimental desktop Android build, which supports |
| // extensions. See https://crbug.com/356905053 |
| class DesktopAndroidExtensionsBrowserTest : public AndroidBrowserTest { |
| public: |
| DesktopAndroidExtensionsBrowserTest() = default; |
| ~DesktopAndroidExtensionsBrowserTest() override = default; |
| |
| content::WebContents* GetActiveWebContents() { |
| return chrome_test_utils::GetActiveWebContents(this); |
| } |
| |
| void SetUpOnMainThread() override { |
| AndroidBrowserTest::SetUpOnMainThread(); |
| |
| host_resolver()->AddRule("*", "127.0.0.1"); |
| ASSERT_TRUE(embedded_test_server()->Start()); |
| } |
| |
| // Returns the main `BrowserContext`. |
| content::BrowserContext* GetBrowserContext() { |
| return GetActiveWebContents()->GetBrowserContext(); |
| } |
| |
| // Attempts to parse and load an extension from the given `file_path` and add |
| // it to the extensions system (which will also activate the extension). |
| // Returns the extension on success; on failure, returns null. |
| scoped_refptr<const Extension> LoadExtensionFromDirectory( |
| const base::FilePath& file_path) { |
| ChromeTestExtensionLoader loader(GetBrowserContext()); |
| return loader.LoadExtension(file_path); |
| } |
| }; |
| |
| // The following is a simple test exercising a basic navigation and script |
| // injection. This doesn't exercise any extensions logic, but ensures Chrome |
| // successfully starts and can navigate the web. |
| IN_PROC_BROWSER_TEST_F(DesktopAndroidExtensionsBrowserTest, SanityCheck) { |
| ASSERT_EQ(TabModelList::models().size(), 1u); |
| |
| EXPECT_TRUE(content::NavigateToURL( |
| GetActiveWebContents(), |
| embedded_test_server()->GetURL("example.com", "/title1.html"))); |
| |
| EXPECT_EQ("This page has no title.", |
| content::EvalJs(GetActiveWebContents(), "document.body.innerText")); |
| } |
| |
| // Tests the ability to parse and validate a simple extension. |
| IN_PROC_BROWSER_TEST_F(DesktopAndroidExtensionsBrowserTest, |
| ParseAndValidateASimpleExtension) { |
| static constexpr char kManifest[] = |
| R"({ |
| "name": "Test Extension", |
| "version": "0.1", |
| "manifest_version": 3 |
| })"; |
| |
| TestExtensionDir test_dir; |
| test_dir.WriteManifest(kManifest); |
| |
| scoped_refptr<const Extension> extension = |
| LoadExtensionFromDirectory(test_dir.UnpackedPath()); |
| ASSERT_TRUE(extension); |
| |
| // Validate the fields in the extension. |
| EXPECT_EQ("Test Extension", extension->name()); |
| EXPECT_EQ("0.1", extension->version().GetString()); |
| EXPECT_EQ(3, extension->manifest_version()); |
| } |
| |
| // Tests the adding an extension to the registry and navigating to a |
| // corresponding page in the extension, verifying the expected content, and |
| // leveraging the chrome.test API to pass a result. The latter verifies the |
| // core extension bindings system and API handling works, including |
| // exercising custom bindings. |
| IN_PROC_BROWSER_TEST_F(DesktopAndroidExtensionsBrowserTest, |
| NavigateToExtensionPage) { |
| static constexpr char kManifest[] = |
| R"({ |
| "name": "Test Extension", |
| "version": "0.1", |
| "manifest_version": 3 |
| })"; |
| static constexpr char kPageHtml[] = |
| R"(<html> |
| Hello, world |
| <script src="page.js"></script> |
| </html>)"; |
| static constexpr char kPageJs[] = |
| R"(chrome.test.runTests([ |
| function sanityCheck() { |
| chrome.test.assertEq(2, 1 + 1); |
| chrome.test.succeed(); |
| } |
| ]);)"; |
| |
| TestExtensionDir test_dir; |
| test_dir.WriteManifest(kManifest); |
| test_dir.WriteFile(FILE_PATH_LITERAL("page.html"), kPageHtml); |
| test_dir.WriteFile(FILE_PATH_LITERAL("page.js"), kPageJs); |
| |
| scoped_refptr<const Extension> extension = |
| LoadExtensionFromDirectory(test_dir.UnpackedPath()); |
| ASSERT_TRUE(extension); |
| |
| GURL extension_page = extension->GetResourceURL("page.html"); |
| |
| ResultCatcher result_catcher; |
| EXPECT_TRUE(content::NavigateToURL(GetActiveWebContents(), extension_page)); |
| EXPECT_EQ(extension_page, GetActiveWebContents()->GetLastCommittedURL()); |
| EXPECT_EQ("Hello, world", |
| content::EvalJs(GetActiveWebContents(), "document.body.innerText")); |
| EXPECT_TRUE(result_catcher.GetNextResult()) << result_catcher.message(); |
| } |
| |
| // Test service worker-based extensions properly load and have the service |
| // worker initialize and run. |
| IN_PROC_BROWSER_TEST_F(DesktopAndroidExtensionsBrowserTest, |
| ServiceWorkerBasedExtension) { |
| static constexpr char kManifest[] = |
| R"({ |
| "name": "Test Extension", |
| "version": "0.1", |
| "manifest_version": 3, |
| "background": {"service_worker": "background.js"} |
| })"; |
| static constexpr char kBackgroundJs[] = |
| R"(chrome.test.runTests([ |
| function sanityCheck() { |
| chrome.test.assertEq(2, 1 + 1); |
| chrome.test.succeed(); |
| } |
| ]);)"; |
| TestExtensionDir test_dir; |
| test_dir.WriteManifest(kManifest); |
| test_dir.WriteFile(FILE_PATH_LITERAL("background.js"), kBackgroundJs); |
| |
| ResultCatcher result_catcher; |
| scoped_refptr<const Extension> extension = |
| LoadExtensionFromDirectory(test_dir.UnpackedPath()); |
| ASSERT_TRUE(extension); |
| ASSERT_TRUE(result_catcher.GetNextResult()) << result_catcher.message(); |
| } |
| |
| // Tests the declarative net request API in extension service workers. |
| IN_PROC_BROWSER_TEST_F(DesktopAndroidExtensionsBrowserTest, |
| DeclarativeNetRequestSupport) { |
| // Load a simple extension that redirects from example.com -> google.com. |
| static constexpr char kManifest[] = |
| R"({ |
| "name": "My Test Extension", |
| "manifest_version": 3, |
| "version": "0.1", |
| "declarative_net_request": { |
| "rule_resources": [{ |
| "id": "ruleset", |
| "enabled": true, |
| "path": "rules.json" |
| }] |
| }, |
| "permissions": ["declarativeNetRequest"], |
| "host_permissions": ["*://example.com/*"] |
| })"; |
| |
| // One rule, which is a redirect from example.com to |
| // http://google.com:<portid>/title2.html. |
| static constexpr char kRulesJson[] = |
| R"([{ |
| "id": 1, |
| "priority": 1, |
| "action": { |
| "type": "redirect", |
| "redirect": { "url": "http://google.com:%d/title2.html" } |
| }, |
| "condition": { |
| "urlFilter": "example.com", |
| "resourceTypes": ["main_frame"] |
| } |
| }])"; |
| |
| TestExtensionDir test_dir; |
| test_dir.WriteManifest(kManifest); |
| test_dir.WriteFile( |
| FILE_PATH_LITERAL("rules.json"), |
| base::StringPrintf(kRulesJson, embedded_test_server()->port())); |
| |
| declarative_net_request::RulesetManagerObserver ruleset_manager_observer( |
| declarative_net_request::RulesMonitorService::Get(GetBrowserContext()) |
| ->ruleset_manager()); |
| |
| scoped_refptr<const Extension> extension = |
| LoadExtensionFromDirectory(test_dir.UnpackedPath()); |
| ASSERT_TRUE(extension); |
| |
| ruleset_manager_observer.WaitForExtensionsWithRulesetsCount(1); |
| |
| GURL url = embedded_test_server()->GetURL("example.com", "/title1.html"); |
| GURL expected_url = |
| embedded_test_server()->GetURL("google.com", "/title2.html"); |
| |
| EXPECT_TRUE( |
| content::NavigateToURL(GetActiveWebContents(), url, expected_url)); |
| EXPECT_EQ(expected_url, GetActiveWebContents()->GetLastCommittedURL()); |
| EXPECT_EQ("This page has a title.", |
| content::EvalJs(GetActiveWebContents(), "document.body.innerText")); |
| } |
| |
| // Verifies content scripts are properly injected. |
| IN_PROC_BROWSER_TEST_F(DesktopAndroidExtensionsBrowserTest, |
| ContentScriptInjection) { |
| // An extension that injects a simple script on match.test sites. |
| static constexpr char kManifest[] = |
| R"({ |
| "name": "Content Script Extension", |
| "manifest_version": 3, |
| "version": "0.1", |
| "content_scripts": [{ |
| "matches": ["*://match.test/*"], |
| "js": ["content_script.js"], |
| "run_at": "document_idle" |
| }] |
| })"; |
| // The script just appends a span to indicate it injected. |
| static constexpr char kContentScriptJs[] = |
| R"(let span = document.createElement('span'); |
| span.textContent = 'content script injected'; |
| document.body.appendChild(span);)"; |
| |
| TestExtensionDir test_dir; |
| test_dir.WriteManifest(kManifest); |
| test_dir.WriteFile(FILE_PATH_LITERAL("content_script.js"), kContentScriptJs); |
| |
| scoped_refptr<const Extension> extension = |
| LoadExtensionFromDirectory(test_dir.UnpackedPath()); |
| ASSERT_TRUE(extension); |
| |
| // Verify scripts were properly parsed. |
| const UserScriptList& content_scripts = |
| ContentScriptsInfo::GetContentScripts(extension.get()); |
| ASSERT_EQ(1u, content_scripts.size()); |
| |
| // Wait for scripts to load (if they haven't already). |
| UserScriptManager* user_script_manager = |
| ExtensionSystem::Get(GetBrowserContext())->user_script_manager(); |
| ExtensionUserScriptLoader* user_script_loader = |
| user_script_manager->GetUserScriptLoaderForExtension(extension->id()); |
| if (!user_script_loader->HasLoadedScripts()) { |
| ContentScriptLoadWaiter waiter(user_script_loader); |
| waiter.Wait(); |
| } |
| |
| // First, navigate to a site that *doesn't* match the extension. The script |
| // should not inject. |
| const GURL no_match_test = |
| embedded_test_server()->GetURL("no-match.test", "/title1.html"); |
| EXPECT_TRUE(content::NavigateToURL(GetActiveWebContents(), no_match_test)); |
| EXPECT_EQ(no_match_test, GetActiveWebContents()->GetLastCommittedURL()); |
| EXPECT_EQ("This page has no title.", |
| content::EvalJs(GetActiveWebContents(), "document.body.innerText")); |
| |
| // Next, navigate to a site that *does* match. The script should inject. |
| const GURL match_test = |
| embedded_test_server()->GetURL("match.test", "/title1.html"); |
| EXPECT_TRUE(content::NavigateToURL(GetActiveWebContents(), match_test)); |
| EXPECT_EQ(match_test, GetActiveWebContents()->GetLastCommittedURL()); |
| EXPECT_EQ("This page has no title. content script injected", |
| content::EvalJs(GetActiveWebContents(), "document.body.innerText")); |
| } |
| |
| // Tests Storage API for StorageArea.local. |
| IN_PROC_BROWSER_TEST_F(DesktopAndroidExtensionsBrowserTest, |
| StorageApiTestStorageAreaLocal) { |
| static constexpr char kManifest[] = |
| R"({ |
| "name": "StorageArea.OnChanged", |
| "version": "0.1", |
| "manifest_version": 3, |
| "permissions": ["storage"], |
| "background": {"service_worker": "background.js"} |
| })"; |
| static constexpr char kBackgroundJs[] = |
| R"(chrome.test.runTests([ |
| function storageAreaOnChanged() { |
| var localStorageArea = chrome.storage.local; |
| chrome.test.listenOnce(localStorageArea.onChanged, |
| function(changes) { |
| chrome.test.assertEq({key:{newValue:'value'}}, changes); |
| }); |
| |
| chrome.test.listenOnce(chrome.storage.onChanged, |
| function(changes, namespace) { |
| chrome.test.assertEq({key:{newValue:'value'}}, changes); |
| chrome.test.assertEq('local', namespace); |
| }); |
| |
| chrome.storage.session.onChanged.addListener( |
| function(changes, namespace) { |
| chrome.test.notifyFail( |
| 'session.onChanged should not be called when local storage update'); |
| }); |
| |
| localStorageArea.set({key: 'value'}); |
| } |
| ]);)"; |
| TestExtensionDir test_dir; |
| test_dir.WriteManifest(kManifest); |
| test_dir.WriteFile(FILE_PATH_LITERAL("background.js"), kBackgroundJs); |
| |
| ResultCatcher result_catcher; |
| scoped_refptr<const Extension> extension = |
| LoadExtensionFromDirectory(test_dir.UnpackedPath()); |
| ASSERT_TRUE(extension); |
| ASSERT_TRUE(result_catcher.GetNextResult()) << result_catcher.message(); |
| } |
| |
| // Tests Storage API for StorageArea.session. |
| IN_PROC_BROWSER_TEST_F(DesktopAndroidExtensionsBrowserTest, |
| StorageApiTestStorageAreaSession) { |
| static constexpr char kManifest[] = |
| R"({ |
| "name": "StorageArea.OnChanged", |
| "version": "0.1", |
| "manifest_version": 3, |
| "permissions": ["storage"], |
| "background": {"service_worker": "background.js"} |
| })"; |
| static constexpr char kBackgroundJs[] = |
| R"(chrome.test.runTests([ |
| function storageAreaOnChanged() { |
| var sessionStorageArea = chrome.storage.session; |
| |
| chrome.test.listenOnce(sessionStorageArea.onChanged, |
| function(changes) { |
| chrome.test.assertEq({key:{newValue:'value'}}, changes); |
| }); |
| |
| chrome.test.listenOnce(chrome.storage.onChanged, |
| function(changes, namespace) { |
| chrome.test.assertEq({key:{newValue:'value'}}, changes); |
| chrome.test.assertEq('session', namespace); |
| }); |
| |
| chrome.storage.local.onChanged.addListener( |
| function(changes, namespace) { |
| chrome.test.notifyFail( |
| 'local.onChanged should not be called when session storage update'); |
| }); |
| |
| sessionStorageArea.set({key: 'value'}); |
| } |
| ]);)"; |
| TestExtensionDir test_dir; |
| test_dir.WriteManifest(kManifest); |
| test_dir.WriteFile(FILE_PATH_LITERAL("background.js"), kBackgroundJs); |
| |
| ResultCatcher result_catcher; |
| scoped_refptr<const Extension> extension = |
| LoadExtensionFromDirectory(test_dir.UnpackedPath()); |
| ASSERT_TRUE(extension); |
| ASSERT_TRUE(result_catcher.GetNextResult()) << result_catcher.message(); |
| } |
| |
| // Tests reading a chrome.extension.* property. |
| IN_PROC_BROWSER_TEST_F(DesktopAndroidExtensionsBrowserTest, |
| ExtensionPropertyRead) { |
| static constexpr char kManifest[] = |
| R"({ |
| "name": "chrome.extension property read", |
| "version": "0.1", |
| "manifest_version": 3, |
| "background": {"service_worker": "background.js"} |
| })"; |
| static constexpr char kBackgroundJs[] = |
| R"(chrome.test.runTests([ |
| function readProperty() { |
| // Test that we can read a property. |
| let incognito = chrome.extension.inIncognitoContext; |
| chrome.test.assertFalse(incognito); |
| chrome.test.succeed(); |
| } |
| ]);)"; |
| TestExtensionDir test_dir; |
| test_dir.WriteManifest(kManifest); |
| test_dir.WriteFile(FILE_PATH_LITERAL("background.js"), kBackgroundJs); |
| |
| ResultCatcher result_catcher; |
| scoped_refptr<const Extension> extension = |
| LoadExtensionFromDirectory(test_dir.UnpackedPath()); |
| ASSERT_TRUE(extension); |
| ASSERT_TRUE(result_catcher.GetNextResult()) << result_catcher.message(); |
| } |
| |
| // Tests passing a basic message between extension contexts. |
| IN_PROC_BROWSER_TEST_F(DesktopAndroidExtensionsBrowserTest, MessagePassing) { |
| static constexpr char kManifest[] = |
| R"({ |
| "name": "Message passing", |
| "version": "0.1", |
| "manifest_version": 3, |
| "background": {"service_worker": "background.js"} |
| })"; |
| |
| // A service worker that will send a message and wait for a reply. |
| static constexpr char kBackgroundJs[] = |
| R"(chrome.test.runTests([ |
| async function sendMessage() { |
| // We wait for the C++ side to be ready; this allows us to open a |
| // tab to listen to the message we'll send. |
| await chrome.test.sendMessage('ready'); |
| |
| const reply = await chrome.runtime.sendMessage('ping'); |
| chrome.test.assertEq('pong', reply); |
| chrome.test.succeed(); |
| }, |
| ]);)"; |
| // This is a basic page that will reply to an incoming message. |
| static constexpr char kPageHtml[] = |
| R"(<html><script src="page.js"></script></html>)"; |
| static constexpr char kPageJs[] = |
| R"(chrome.runtime.onMessage.addListener(async(msg, sender, sendReply) => { |
| chrome.test.assertEq(msg, 'ping'); |
| sendReply('pong'); |
| });)"; |
| |
| TestExtensionDir test_dir; |
| test_dir.WriteManifest(kManifest); |
| test_dir.WriteFile(FILE_PATH_LITERAL("background.js"), kBackgroundJs); |
| test_dir.WriteFile(FILE_PATH_LITERAL("page.js"), kPageJs); |
| test_dir.WriteFile(FILE_PATH_LITERAL("page.html"), kPageHtml); |
| |
| ResultCatcher result_catcher; |
| ExtensionTestMessageListener listener("ready", ReplyBehavior::kWillReply); |
| scoped_refptr<const Extension> extension = |
| LoadExtensionFromDirectory(test_dir.UnpackedPath()); |
| ASSERT_TRUE(extension); |
| |
| ASSERT_TRUE(listener.WaitUntilSatisfied()); |
| |
| // Open a tab to the listening page, and reply to the extension when it's |
| // loaded. |
| GURL extension_page = extension->GetResourceURL("page.html"); |
| EXPECT_TRUE(content::NavigateToURL(GetActiveWebContents(), extension_page)); |
| EXPECT_TRUE(content::WaitForLoadStop(GetActiveWebContents())); |
| EXPECT_EQ(extension_page, GetActiveWebContents()->GetLastCommittedURL()); |
| |
| listener.Reply("done"); |
| |
| ASSERT_TRUE(result_catcher.GetNextResult()) << result_catcher.message(); |
| } |
| |
| } // namespace extensions |
