[BackgroundSync] Only allow SyncManager.register to occur from main frame

content/browser/background_sync/background_sync_browsertest.cc

 // Copyright 2015 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 <set>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/strings/string_split.h"
@@ skipping 20 matching lines @@
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::NetworkChangeNotifier;
 
 namespace content {
 
 namespace {
 
 const char kDefaultTestURL[] = "/background_sync/test.html";
+const char kEmptyURL[] = "/background_sync/empty.html";
+const char kRegisterSyncURL[] = "/background_sync/register_sync.html";
 
 const char kSuccessfulOperationPrefix[] = "ok - ";
 
 std::string BuildScriptString(const std::string& function,
                               const std::string& argument) {
   return base::StringPrintf("%s('%s');", function.c_str(), argument.c_str());
 }
 
 std::string BuildExpectedResult(const std::string& tag,
                                 const std::string& action) {
@@ skipping 130 matching lines @@
   bool GetRegistrationOneShot(const std::string& tag);
   bool GetRegistrationOneShotFromServiceWorker(const std::string& tag);
   bool MatchRegistrations(const std::string& script_result,
                           const std::vector<std::string>& expected_tags);
   bool GetRegistrationsOneShot(const std::vector<std::string>& expected_tags);
   bool GetRegistrationsOneShotFromServiceWorker(
       const std::vector<std::string>& expected_tags);
   bool CompleteDelayedOneShot();
   bool RejectDelayedOneShot();
 
+  net::EmbeddedTestServer* https_server() { return https_server_.get(); }
+
  private:
   scoped_ptr<net::EmbeddedTestServer> https_server_;
   Shell* shell_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundSyncBrowserTest);
 };
 
 bool BackgroundSyncBrowserTest::OneShotPending(const std::string& tag) {
   bool is_pending;
   base::RunLoop run_loop;
@@ skipping 412 matching lines @@
   SetMaxSyncAttempts(2);
 
   EXPECT_TRUE(RegisterOneShot("delay"));
   EXPECT_TRUE(RejectDelayedOneShot());
   EXPECT_TRUE(PopConsole("ok - delay rejected"));
 
   // Verify that the oneshot is still around and waiting to try again.
   EXPECT_TRUE(OneShotPending("delay"));
 }
 
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest, RegisterFromNonMainFrame) {
+  std::string script_result;
+  GURL url = https_server()->GetURL(kEmptyURL);
+  EXPECT_TRUE(
+      RunScript(BuildScriptString("registerOneShotFromLocalFrame", url.spec()),
+                &script_result));
+  EXPECT_EQ(BuildExpectedResult("iframe", "failed to register sync"),
+            script_result);
+}
+
+IN_PROC_BROWSER_TEST_F(BackgroundSyncBrowserTest,
+                       RegisterFromServiceWorkerWithoutMainFrameHost) {
+  // Start a second https server to use as a second origin.
+  net::EmbeddedTestServer alt_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  alt_server.ServeFilesFromSourceDirectory("content/test/data");
+  ASSERT_TRUE(alt_server.Start());
+
+  std::string script_result;
+  GURL url = alt_server.GetURL(kRegisterSyncURL);
+  EXPECT_TRUE(
+      RunScript(BuildScriptString("registerOneShotFromCrossOriginServiceWorker",
+                                  url.spec()),
+                &script_result));
+  EXPECT_EQ(BuildExpectedResult("worker", "failed to register sync"),
+            script_result);
+}
+
 }  // namespace content