Declarative Web Request: firstPartyForCookiesUrl

chrome/test/data/extensions/api_test/webrequest/test_declarative.js

 // 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.
 
 var onRequest = chrome.declarativeWebRequest.onRequest;
 var AddResponseHeader =
     chrome.declarativeWebRequest.AddResponseHeader;
 var RequestMatcher = chrome.declarativeWebRequest.RequestMatcher;
 var CancelRequest = chrome.declarativeWebRequest.CancelRequest;
 var RedirectByRegEx = chrome.declarativeWebRequest.RedirectByRegEx;
@@ skipping 38 matching lines @@
 function getURLHttpRedirectTest() {
   return getServerURL(
       "files/extensions/api_test/webrequest/declarative/a.html");
 }
 
 function getURLHttpWithHeaders() {
   return getServerURL(
       "files/extensions/api_test/webrequest/declarative/headers.html");
 }
 
-function getURLThirdParty() {
+function getURLOfHTMLWithThirdParty() {
   // Returns the URL of a HTML document with a third-party resource.
   return getServerURL(
       "files/extensions/api_test/webrequest/declarative/third-party.html");
 }
 
 function getURLSetCookie() {
   return getServerURL('set-cookie?Foo=Bar');
 }
 
 function getURLSetCookie2() {
   return getServerURL('set-cookie?passedCookie=Foo&editedCookie=Foo&' +
                       'deletedCookie=Foo');
 }
 
 function getURLEchoCookie() {
   return getServerURL('echoheader?Cookie');
 }
 
 function getURLHttpXHRData() {
   return getServerURL("files/extensions/api_test/webrequest/xhr/data.json",
                       "b.com");
 }
 
 // Shared test sections.
 function cancelThirdPartyExpected() {
     return [
       { label: "onBeforeRequest",
         event: "onBeforeRequest",
         details: {
-          url: getURLThirdParty(),
-          frameUrl: getURLThirdParty()
+          url: getURLOfHTMLWithThirdParty(),
+          frameUrl: getURLOfHTMLWithThirdParty()
         }
       },
       { label: "onBeforeSendHeaders",
         event: "onBeforeSendHeaders",
-        details: {url: getURLThirdParty()}
+        details: {url: getURLOfHTMLWithThirdParty()}
       },
       { label: "onSendHeaders",
         event: "onSendHeaders",
-        details: {url: getURLThirdParty()}
+        details: {url: getURLOfHTMLWithThirdParty()}
       },
       { label: "onHeadersReceived",
         event: "onHeadersReceived",
         details: {
-          url: getURLThirdParty(),
+          url: getURLOfHTMLWithThirdParty(),
           statusLine: "HTTP/1.0 200 OK"
         }
       },
       { label: "onResponseStarted",
         event: "onResponseStarted",
         details: {
-          url: getURLThirdParty(),
+          url: getURLOfHTMLWithThirdParty(),
           fromCache: false,
           ip: "127.0.0.1",
           statusCode: 200,
           statusLine: "HTTP/1.0 200 OK"
         }
       },
       { label: "onCompleted",
         event: "onCompleted",
         details: {
           fromCache: false,
           ip: "127.0.0.1",
-          url: getURLThirdParty(),
+          url: getURLOfHTMLWithThirdParty(),
           statusCode: 200,
           statusLine: "HTTP/1.0 200 OK"
         }
       },
       { label: "img-onBeforeRequest",
         event: "onBeforeRequest",
         details: {
           type: "image",
           url: "http://non_existing_third_party.com/image.png",
-          frameUrl: getURLThirdParty()
+          frameUrl: getURLOfHTMLWithThirdParty()
         }
       },
       { label: "img-onErrorOccurred",
         event: "onErrorOccurred",
         details: {
           error: "net::ERR_BLOCKED_BY_CLIENT",
           fromCache: false,
           type: "image",
           url: "http://non_existing_third_party.com/image.png"
         }
@@ skipping 97 matching lines @@
       function() {navigateAndWait(getURLHttpWithHeaders());}
     );
   },
   // Tests that "thirdPartyForCookies: true" matches third party requests.
   function testThirdParty() {
     ignoreUnexpected = false;
     expect(cancelThirdPartyExpected(), cancelThirdPartyExpectedOrder());
     onRequest.addRules(
       [ {'conditions': [new RequestMatcher({thirdPartyForCookies: true})],
          'actions': [new chrome.declarativeWebRequest.CancelRequest()]},],
-      function() {navigateAndWait(getURLThirdParty());}
+      function() {navigateAndWait(getURLOfHTMLWithThirdParty());}
     );
   },
 
   // Tests that "thirdPartyForCookies: false" matches first party requests,
   // by cancelling all requests, and overriding the cancelling rule only for
   // requests matching "thirdPartyForCookies: false".
   function testFirstParty() {
     ignoreUnexpected = false;
     expect(cancelThirdPartyExpected(), cancelThirdPartyExpectedOrder());
     onRequest.addRules(
       [ {'priority': 2,
          'conditions': [
            new RequestMatcher({thirdPartyForCookies: false})
          ],
          'actions': [
            new chrome.declarativeWebRequest.IgnoreRules({
               lowerPriorityThan: 2 })
          ]
         },
         {'priority': 1,
          'conditions': [new RequestMatcher({})],
          'actions': [new chrome.declarativeWebRequest.CancelRequest()]
         },
       ],
-      function() {navigateAndWait(getURLThirdParty());}
+      function() {navigateAndWait(getURLOfHTMLWithThirdParty());}
     );
   },
 
+  function testFirstPartyForCookiesUrl() {
+    // This is an end-to-end test for firstPartyForCookies. The choice of URL to
+    // navigate to is purely arbitrary.
+    ignoreUnexpected = false;
+    expect(
+      [
+        { label: "onBeforeRequest",
+          event: "onBeforeRequest",
+          details: {
+            url: getURLOfHTMLWithThirdParty(),
+            frameUrl: getURLOfHTMLWithThirdParty()
+          }
+        },
+        { label: "onErrorOccurred",
+          event: "onErrorOccurred",
+          details: {
+            url: getURLOfHTMLWithThirdParty(),
+            fromCache: false,
+            error: "net::ERR_BLOCKED_BY_CLIENT"
+          }
+        },
+      ],
+      [ ["onBeforeRequest", "onErrorOccurred"] ]);
+    onRequest.addRules(
+      [ {'conditions': [
+           new RequestMatcher({
+             firstPartyForCookiesUrl: {
+               hostEquals: testServer
+             }
+           })
+         ],
+         'actions': [new chrome.declarativeWebRequest.CancelRequest()]
+        },
+      ],
+      function() {navigateAndWait(getURLOfHTMLWithThirdParty());}
+    );
+  },
+
   function testRedirectRequest() {
     ignoreUnexpected = true;
     expect(
       [
         { label: "onBeforeRequest-a",
           event: "onBeforeRequest",
           details: {
             type: "main_frame",
             url: getURLHttpComplex(),
             frameUrl: getURLHttpComplex()
@@ skipping 404 matching lines @@
              },
              'requestHeaders': [{ nameContains: "" }],
              'excludeRequestHeaders': [{ valueContains: ["", "value123"] }]
               })],
          'actions': [new CancelRequest()]}
       ],
       function() {navigateAndWait(getURLHttpSimple());}
     );
   },
   ]);