Only whitelist messages.json files in _locales for content verification

chrome/browser/extensions/content_verifier_browsertest.cc

 // Copyright 2014 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 <list>
 #include <set>
 #include <string>
 
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
@@ skipping 475 matching lines @@
     EXPECT_TRUE(unload_observer_->WaitForUnload(id));
     ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
     int reasons = prefs->GetDisableReasons(id);
     EXPECT_TRUE(reasons & Extension::DISABLE_CORRUPTED);
 
     // This needs to happen before the ExtensionRegistry gets deleted, which
     // happens before TearDownOnMainThread is called.
     unload_observer_.reset();
   }
 
+  void TestContentScriptExtension(const std::string& crx_relpath,
+                                  const std::string& id,
+                                  const std::string& script_relpath) {
+    VerifierObserver verifier_observer;
+    ContentVerifier::SetObserverForTests(&verifier_observer);
+    // Install the extension with content scripts. The initial read of the
+    // content scripts will fail verification because they are read before the
+    // content verification system has completed a one-time processing of the
+    // expected hashes. (The extension only contains the root level hashes of
+    // the merkle tree, but the content verification system builds the entire
+    // tree and caches it in the extension install directory - see
+    // ContentHashFetcher for more details).
+    const Extension* extension = InstallExtensionFromWebstore(
+        test_data_dir_.AppendASCII(crx_relpath), 1);
+    ASSERT_TRUE(extension);
+    ASSERT_EQ(extension->id(), id);
+
+    // Wait for the content verification code to finish processing the hashes.
+    if (!base::ContainsKey(verifier_observer.completed_fetches(), id))
+      verifier_observer.WaitForFetchComplete(id);
+
+    // Now disable the extension, since content scripts are read at enable time,
+    // set up our job observer, and re-enable, expecting a success this time.
+    DisableExtension(id);
+    JobObserver job_observer;
+    ContentVerifyJob::SetObserverForTests(&job_observer);
+    base::FilePath script_relfilepath =
+        base::FilePath().AppendASCII(script_relpath);
+    job_observer.ExpectJobResult(id, script_relfilepath,
+                                 JobObserver::Result::SUCCESS);
+    EnableExtension(id);
+    EXPECT_TRUE(job_observer.WaitForExpectedJobs());
+
+    // Now alter the contents of the content script, reload the extension, and
+    // expect to see a job failure due to the content script content hash not
+    // being what was signed by the webstore.
+    base::FilePath scriptfile = extension->path().AppendASCII(script_relpath);
+    std::string extra = "some_extra_function_call();";
+    ASSERT_TRUE(base::AppendToFile(scriptfile, extra.data(), extra.size()));
+    DisableExtension(id);
+    job_observer.ExpectJobResult(id, script_relfilepath,
+                                 JobObserver::Result::FAILURE);
+    EnableExtension(id);
+    EXPECT_TRUE(job_observer.WaitForExpectedJobs());
+
+    ContentVerifyJob::SetObserverForTests(NULL);
+  }
+
  protected:
   JobDelegate delegate_;
   std::unique_ptr<RegistryObserver> unload_observer_;
   GURL page_url_;
 };
 
 IN_PROC_BROWSER_TEST_F(ContentVerifierTest, FailOnRead) {
   EXPECT_EQ(0, delegate_.bytes_read_failed());
   delegate_.fail_next_read();
   OpenPageAndWaitForUnload();
@@ skipping 52 matching lines @@
   // read again.
   DisableExtension(id);
   EnableExtension(id);
 
   EXPECT_TRUE(job_observer.WaitForExpectedJobs());
 
   ContentVerifyJob::SetObserverForTests(NULL);
 }
 
 IN_PROC_BROWSER_TEST_F(ContentVerifierTest, ContentScripts) {
-  VerifierObserver verifier_observer;
-  ContentVerifier::SetObserverForTests(&verifier_observer);
+  TestContentScriptExtension("content_verifier/content_script.crx",
+                             "jmllhlobpjcnnomjlipadejplhmheiif", "script.js");
+}
 
-  // Install an extension with content scripts. The initial read of the content
-  // scripts will fail verification because they are read before the content
-  // verification system has completed a one-time processing of the expected
-  // hashes. (The extension only contains the root level hashes of the merkle
-  // tree, but the content verification system builds the entire tree and
-  // caches it in the extension install directory - see ContentHashFetcher for
-  // more details).
-  std::string id = "jmllhlobpjcnnomjlipadejplhmheiif";
-  const Extension* extension = InstallExtensionFromWebstore(
-      test_data_dir_.AppendASCII("content_verifier/content_script.crx"), 1);
-  ASSERT_TRUE(extension);
-  ASSERT_EQ(extension->id(), id);
-
-  // Wait for the content verification code to finish processing the hashes.
-  if (!base::ContainsKey(verifier_observer.completed_fetches(), id))
-    verifier_observer.WaitForFetchComplete(id);
-
-  // Now disable the extension, since content scripts are read at enable time,
-  // set up our job observer, and re-enable, expecting a success this time.
-  DisableExtension(id);
-  JobObserver job_observer;
-  ContentVerifyJob::SetObserverForTests(&job_observer);
-  job_observer.ExpectJobResult(id,
-                               base::FilePath(FILE_PATH_LITERAL("script.js")),
-                               JobObserver::Result::SUCCESS);
-  EnableExtension(id);
-  EXPECT_TRUE(job_observer.WaitForExpectedJobs());
-
-  // Now alter the contents of the content script, reload the extension, and
-  // expect to see a job failure due to the content script content hash not
-  // being what was signed by the webstore.
-  base::FilePath scriptfile = extension->path().AppendASCII("script.js");
-  std::string extra = "some_extra_function_call();";
-  ASSERT_TRUE(base::AppendToFile(scriptfile, extra.data(), extra.size()));
-  DisableExtension(id);
-  job_observer.ExpectJobResult(id,
-                               base::FilePath(FILE_PATH_LITERAL("script.js")),
-                               JobObserver::Result::FAILURE);
-  EnableExtension(id);
-  EXPECT_TRUE(job_observer.WaitForExpectedJobs());
-
-  ContentVerifyJob::SetObserverForTests(NULL);
+IN_PROC_BROWSER_TEST_F(ContentVerifierTest, ContentScriptsInLocales) {
+  TestContentScriptExtension("content_verifier/content_script_locales.crx",
+                             "jaghonccckpcikmliipifpoodmeofoon",
+                             "_locales/en/content_script.js");
 }
 
 // Tests the case of a corrupt extension that is force-installed by policy and
 // should not be allowed to be manually uninstalled/disabled by the user.
 IN_PROC_BROWSER_TEST_F(ContentVerifierTest, PolicyCorrupted) {
   ExtensionSystem* system = ExtensionSystem::Get(profile());
   ExtensionService* service = system->extension_service();
 
   // The id of our test extension.
   std::string id("npnbmohejbjohgpjnmjagbafnjhkmgko");
@@ skipping 185 matching lines @@
   // Assert that the first reinstall action happened with a delay of 0, and
   // then kept growing each additional time.
   ASSERT_EQ(iterations, calls.size());
   EXPECT_EQ(base::TimeDelta(), delay_tracker.calls()[0]);
   for (size_t i = 1; i < delay_tracker.calls().size(); i++) {
     EXPECT_LT(calls[i - 1], calls[i]);
   }
 }
 
 }  // namespace extensions