extensions: Change ScopedTempDir::path() to GetPath()

chrome/browser/extensions/api/declarative_content/declarative_content_apitest.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
@@ skipping 127 matching lines @@
         "\"incognito\": \"split\"");
     ASSERT_NE(kDeclarativeContentManifest, manifest);
   }
   ext_dir_.WriteManifest(manifest);
   ext_dir_.WriteFile(FILE_PATH_LITERAL("background.js"),
                      kIncognitoSpecificBackground);
 
   ExtensionTestMessageListener ready("ready", false);
   ExtensionTestMessageListener ready_incognito("ready (split)", false);
 
-  const Extension* extension = is_enabled_in_incognito ?
-      LoadExtensionIncognito(ext_dir_.unpacked_path()) :
-      LoadExtension(ext_dir_.unpacked_path());
+  const Extension* extension =
+      is_enabled_in_incognito ? LoadExtensionIncognito(ext_dir_.UnpackedPath())
+                              : LoadExtension(ext_dir_.UnpackedPath());
   ASSERT_TRUE(extension);
 
   Browser* incognito_browser = CreateIncognitoBrowser();
   const ExtensionAction* incognito_page_action =
       ExtensionActionManager::Get(incognito_browser->profile())->
       GetPageAction(*extension);
   ASSERT_TRUE(incognito_page_action);
 
   ASSERT_TRUE(ready.WaitUntilSatisfied());
   if (is_enabled_in_incognito && mode == SPLIT)
@@ skipping 39 matching lines @@
 }
 
 void DeclarativeContentApiTest::CheckBookmarkEvents(bool match_is_bookmarked) {
   ext_dir_.WriteManifest(kDeclarativeContentManifest);
   ext_dir_.WriteFile(FILE_PATH_LITERAL("background.js"), kBackgroundHelpers);
 
   content::WebContents* const tab =
       browser()->tab_strip_model()->GetWebContentsAt(0);
   const int tab_id = ExtensionTabUtil::GetTabId(tab);
 
-  const Extension* extension = LoadExtension(ext_dir_.unpacked_path());
+  const Extension* extension = LoadExtension(ext_dir_.UnpackedPath());
   ASSERT_TRUE(extension);
   const ExtensionAction* page_action = ExtensionActionManager::Get(
       browser()->profile())->GetPageAction(*extension);
   ASSERT_TRUE(page_action);
 
   NavigateInRenderer(tab, GURL("http://test1/"));
   EXPECT_FALSE(page_action->GetIsVisible(tab_id));
 
   static const char kSetIsBookmarkedRule[] =
       "setRules([{\n"
@@ skipping 50 matching lines @@
       "}\n"
       "\n"
       "var testEvent = chrome.declarativeContent.onPageChanged;\n"
       "\n"
       "testEvent.removeRules(undefined, function() {\n"
       "  testEvent.addRules([rule], function() {\n"
       "    chrome.test.sendMessage(\"ready\")\n"
       "  });\n"
       "});\n");
   ExtensionTestMessageListener ready("ready", false);
-  const Extension* extension = LoadExtension(ext_dir_.unpacked_path());
+  const Extension* extension = LoadExtension(ext_dir_.UnpackedPath());
   ASSERT_TRUE(extension);
   const ExtensionAction* page_action =
       ExtensionActionManager::Get(browser()->profile())->
       GetPageAction(*extension);
   ASSERT_TRUE(page_action);
 
   ASSERT_TRUE(ready.WaitUntilSatisfied());
   content::WebContents* const tab =
       browser()->tab_strip_model()->GetWebContentsAt(0);
   const int tab_id = ExtensionTabUtil::GetTabId(tab);
@@ skipping 59 matching lines @@
       "};\n"
       "\n"
       "var testEvent = chrome.declarativeContent.onPageChanged;\n"
       "\n"
       "testEvent.removeRules(undefined, function() {\n"
       "  testEvent.addRules([rule1, rule2], function() {\n"
       "    chrome.test.sendMessage(\"ready\");\n"
       "  });\n"
       "});\n");
   ExtensionTestMessageListener ready("ready", false);
-  const Extension* extension = LoadExtension(ext_dir_.unpacked_path());
+  const Extension* extension = LoadExtension(ext_dir_.UnpackedPath());
   ASSERT_TRUE(extension);
   const ExtensionAction* page_action =
       ExtensionActionManager::Get(browser()->profile())
           ->GetPageAction(*extension);
   ASSERT_TRUE(page_action);
 
   ASSERT_TRUE(ready.WaitUntilSatisfied());
   content::WebContents* const tab =
       browser()->tab_strip_model()->GetWebContentsAt(0);
   const int tab_id = ExtensionTabUtil::GetTabId(tab);
 
   // This navigation matches both rules.
   NavigateInRenderer(tab, GURL("http://test1/"));
 
   EXPECT_TRUE(page_action->GetIsVisible(tab_id));
 }
 
 // Tests that the rules are evaluated at the time they are added or removed.
 IN_PROC_BROWSER_TEST_F(DeclarativeContentApiTest, RulesEvaluatedOnAddRemove) {
   ext_dir_.WriteManifest(kDeclarativeContentManifest);
   ext_dir_.WriteFile(FILE_PATH_LITERAL("background.js"), kBackgroundHelpers);
-  const Extension* extension = LoadExtension(ext_dir_.unpacked_path());
+  const Extension* extension = LoadExtension(ext_dir_.UnpackedPath());
   ASSERT_TRUE(extension);
   const ExtensionAction* page_action =
       ExtensionActionManager::Get(browser()->profile())->
       GetPageAction(*extension);
   ASSERT_TRUE(page_action);
 
   content::WebContents* const tab =
       browser()->tab_strip_model()->GetWebContentsAt(0);
   const int tab_id = ExtensionTabUtil::GetTabId(tab);
 
@@ skipping 49 matching lines @@
       "    \"actions\": [{\n"
       "      \"type\": \"declarativeContent.ShowPageAction\"\n"
       "    }],\n"
       "    \"conditions\": [{\n"
       "      \"type\": \"declarativeContent.PageStateMatcher\",\n"
       "      \"pageUrl\": {\"hostPrefix\": \"test1\"}\n"
       "    }]\n"
       "  }]\n"
       "}\n";
   ext_dir_.WriteManifest(manifest);
-  const Extension* extension = LoadExtension(ext_dir_.unpacked_path());
+  const Extension* extension = LoadExtension(ext_dir_.UnpackedPath());
   ASSERT_TRUE(extension);
   const ExtensionAction* page_action =
       ExtensionActionManager::Get(browser()->profile())
           ->GetPageAction(*extension);
   ASSERT_TRUE(page_action);
 
   content::WebContents* const tab =
       browser()->tab_strip_model()->GetWebContentsAt(0);
   const int tab_id = ExtensionTabUtil::GetTabId(tab);
 
@@ skipping 38 matching lines @@
   content::WebContents* const incognito_tab =
       incognito_browser->tab_strip_model()->GetWebContentsAt(0);
   const int incognito_tab_id = ExtensionTabUtil::GetTabId(incognito_tab);
 
   NavigateInRenderer(incognito_tab, GURL("http://test_normal/"));
 
   ext_dir_.WriteManifest(kDeclarativeContentManifest);
   ext_dir_.WriteFile(FILE_PATH_LITERAL("background.js"),
                      kIncognitoSpecificBackground);
   ExtensionTestMessageListener ready("ready", false);
-  const Extension* extension = LoadExtensionIncognito(ext_dir_.unpacked_path());
+  const Extension* extension = LoadExtensionIncognito(ext_dir_.UnpackedPath());
   ASSERT_TRUE(extension);
   ASSERT_TRUE(ready.WaitUntilSatisfied());
 
   const ExtensionAction* incognito_page_action =
       ExtensionActionManager::Get(incognito_browser->profile())->
       GetPageAction(*extension);
   ASSERT_TRUE(incognito_page_action);
 
   // The page action should be shown.
   EXPECT_TRUE(incognito_page_action->GetIsVisible(incognito_tab_id));
@@ skipping 69 matching lines @@
 // Fails on XP: http://crbug.com/515717
 #define MAYBE_UninstallWhileActivePageAction \
   DISABLED_UninstallWhileActivePageAction
 #else
 #define MAYBE_UninstallWhileActivePageAction UninstallWhileActivePageAction
 #endif
 IN_PROC_BROWSER_TEST_F(DeclarativeContentApiTest,
                        MAYBE_UninstallWhileActivePageAction) {
   ext_dir_.WriteManifest(kDeclarativeContentManifest);
   ext_dir_.WriteFile(FILE_PATH_LITERAL("background.js"), kBackgroundHelpers);
-  const Extension* extension = LoadExtension(ext_dir_.unpacked_path());
+  const Extension* extension = LoadExtension(ext_dir_.UnpackedPath());
   ASSERT_TRUE(extension);
   const std::string extension_id = extension->id();
   const ExtensionAction* page_action = ExtensionActionManager::Get(
       browser()->profile())->GetPageAction(*extension);
   ASSERT_TRUE(page_action);
 
   const std::string kTestRule =
       "setRules([{\n"
       "  conditions: [new PageStateMatcher({\n"
       "                   pageUrl: {hostPrefix: \"test\"}})],\n"
@@ skipping 38 matching lines @@
   content::WebContents* const tab =
       browser()->tab_strip_model()->GetWebContentsAt(0);
   const int tab_id = ExtensionTabUtil::GetTabId(tab);
 
   ASSERT_TRUE(content::ExecuteScript(
       tab, "document.body.innerHTML = '<iframe src=\"http://test2\">';"));
   // Replace the iframe to destroy its WebFrame.
   ASSERT_TRUE(content::ExecuteScript(
       tab, "document.body.innerHTML = '<span class=\"foo\">';"));
 
-  const Extension* extension = LoadExtension(ext_dir_.unpacked_path());
+  const Extension* extension = LoadExtension(ext_dir_.UnpackedPath());
   ASSERT_TRUE(extension);
   const ExtensionAction* page_action = ExtensionActionManager::Get(
       browser()->profile())->GetPageAction(*extension);
   ASSERT_TRUE(page_action);
   EXPECT_FALSE(page_action->GetIsVisible(tab_id));
 
   EXPECT_EQ("rule0",
             ExecuteScriptInBackgroundPage(
                 extension->id(),
                 "setRules([{\n"
@@ skipping 37 matching lines @@
 
   void RunTest() {
     // Load an extension without a page action.
     std::string manifest_without_page_action = kDeclarativeContentManifest;
     base::ReplaceSubstringsAfterOffset(&manifest_without_page_action, 0,
                                        "\"page_action\": {},", "");
     ASSERT_NE(kDeclarativeContentManifest, manifest_without_page_action);
     ext_dir_.WriteManifest(manifest_without_page_action);
     ext_dir_.WriteFile(FILE_PATH_LITERAL("background.js"), kBackgroundHelpers);
 
-    const Extension* extension = LoadExtension(ext_dir_.unpacked_path());
+    const Extension* extension = LoadExtension(ext_dir_.UnpackedPath());
     ASSERT_TRUE(extension);
 
     const char kScript[] =
         "setRules([{\n"
         "  conditions: [new PageStateMatcher({\n"
         "                   pageUrl: {hostPrefix: \"test\"}})],\n"
         "  actions: [new ShowPageAction()]\n"
         "}], 'test_rule');\n";
     const char kErrorSubstr[] = "without a page action";
     std::string result =
@@ skipping 62 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(DeclarativeContentApiTest,
                        CanonicalizesPageStateMatcherCss) {
   ext_dir_.WriteManifest(kDeclarativeContentManifest);
   ext_dir_.WriteFile(
       FILE_PATH_LITERAL("background.js"),
       "var PageStateMatcher = chrome.declarativeContent.PageStateMatcher;\n"
       "function Return(obj) {\n"
       "  window.domAutomationController.send('' + obj);\n"
       "}\n");
-  const Extension* extension = LoadExtension(ext_dir_.unpacked_path());
+  const Extension* extension = LoadExtension(ext_dir_.UnpackedPath());
   ASSERT_TRUE(extension);
 
   EXPECT_EQ("input[type=\"password\"]",
             ExecuteScriptInBackgroundPage(
                 extension->id(),
                 "var psm = new PageStateMatcher(\n"
                 "    {css: [\"input[type='password']\"]});\n"
                 "Return(psm.css);"));
 
   EXPECT_THAT(ExecuteScriptInBackgroundPage(
@@ skipping 56 matching lines @@
   // Add a web contents to the tab strip in a way that doesn't trigger
   // NOTIFICATION_TAB_ADDED.
   content::WebContents* contents = content::WebContents::Create(
       content::WebContents::CreateParams(profile()));
   browser()->tab_strip_model()->AppendWebContents(contents, false);
 
   // The actual extension contents don't matter here -- we're just looking to
   // trigger OnExtensionLoaded.
   ext_dir_.WriteManifest(kDeclarativeContentManifest);
   ext_dir_.WriteFile(FILE_PATH_LITERAL("background.js"), kBackgroundHelpers);
-  ASSERT_TRUE(LoadExtension(ext_dir_.unpacked_path()));
+  ASSERT_TRUE(LoadExtension(ext_dir_.UnpackedPath()));
 }
 
 // https://crbug.com/501225
 IN_PROC_BROWSER_TEST_F(DeclarativeContentApiTest,
                        PendingWebContentsClearedOnRemoveRules) {
   ext_dir_.WriteManifest(kDeclarativeContentManifest);
   ext_dir_.WriteFile(FILE_PATH_LITERAL("background.js"), kBackgroundHelpers);
-  const Extension* extension = LoadExtension(ext_dir_.unpacked_path());
+  const Extension* extension = LoadExtension(ext_dir_.UnpackedPath());
   ASSERT_TRUE(extension);
   const ExtensionAction* page_action = ExtensionActionManager::Get(
       browser()->profile())->GetPageAction(*extension);
   ASSERT_TRUE(page_action);
 
   // Create two tabs.
   content::WebContents* const tab1 =
       browser()->tab_strip_model()->GetWebContentsAt(0);
 
   AddTabAtIndex(1, GURL("http://test2/"), ui::PAGE_TRANSITION_LINK);
@@ skipping 38 matching lines @@
 #else
 #define MAYBE_RemoveAllRulesAfterExtensionUninstall \
   RemoveAllRulesAfterExtensionUninstall
 #endif
 IN_PROC_BROWSER_TEST_F(DeclarativeContentApiTest,
                        MAYBE_RemoveAllRulesAfterExtensionUninstall) {
   ext_dir_.WriteManifest(kDeclarativeContentManifest);
   ext_dir_.WriteFile(FILE_PATH_LITERAL("background.js"), kBackgroundHelpers);
 
   // Load the extension, add a rule, then uninstall the extension.
-  const Extension* extension = LoadExtension(ext_dir_.unpacked_path());
+  const Extension* extension = LoadExtension(ext_dir_.UnpackedPath());
   ASSERT_TRUE(extension);
 
   const std::string kAddTestRule =
       "addRules([{\n"
       "  id: '1',\n"
       "  conditions: [],\n"
       "  actions: [new ShowPageAction()]\n"
       "}], 'add_rule');\n";
   EXPECT_EQ("add_rule",
             ExecuteScriptInBackgroundPage(extension->id(), kAddTestRule));
 
   ExtensionService* extension_service = extensions::ExtensionSystem::Get(
       browser()->profile())->extension_service();
 
   base::string16 error;
   ASSERT_TRUE(extension_service->UninstallExtension(
       extension->id(),
       UNINSTALL_REASON_FOR_TESTING,
       base::Bind(&base::DoNothing),
       &error));
   ASSERT_EQ(base::ASCIIToUTF16(""), error);
 
   // Reload the extension, then add and remove a rule.
-  extension = LoadExtension(ext_dir_.unpacked_path());
+  extension = LoadExtension(ext_dir_.UnpackedPath());
   ASSERT_TRUE(extension);
 
   EXPECT_EQ("add_rule",
             ExecuteScriptInBackgroundPage(extension->id(), kAddTestRule));
 
   const std::string kRemoveTestRule1 = "removeRule('1', 'remove_rule1');\n";
   EXPECT_EQ("remove_rule1",
             ExecuteScriptInBackgroundPage(extension->id(), kRemoveTestRule1));
 }
 
 
 // TODO(wittman): Once ChromeContentRulesRegistry operates on condition and
 // action interfaces, add a test that checks that a navigation always evaluates
 // consistent URL state for all conditions. i.e.: if condition1 evaluates to
 // false on url0 and true on url1, and condition2 evaluates to true on url0 and
 // false on url1, navigate from url0 to url1 and validate that no action is
 // triggered. Do the same when navigating back to url0. This kind of test is
 // unfortunately not feasible with the current implementation and the existing
 // supported conditions and actions.
 
 }  // namespace
 }  // namespace extensions