Add SRA support for Doubleclick Fast Fetch Traffic

ads/google/a4a/line-delimited-response-handler.js

@@ -0,0 +1,116 @@
+/**
+ * Copyright 2017 The AMP HTML Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS-IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+ import {dev} from '../../../src/log';
+ import {isObject} from '../../../src/types';
+
+ /**
+  * Creates an XHR streaming request with expected response format of repeated
+  * pairs of JSON object metadata then string HTML delimited by line returns.
+  *
+  * @param {!../../../src/service/xhr-impl.Xhr} xhr
+  * @param {string} url
+  * @param {!function(string, !Object<string, *>, boolean)} slotCallback called
+  *    with creative, metadata, and boolean indicating if completed.  Failure to
+  *    JSON parse metadata will cause empty object to be given.
+  * @param {?../../../src/service/xhr-impl.FetchInitDef=} opt_init
+  * @return {!Promise<!../../../src/service/xhr-impl.FetchResponse>} response,
+  *    note that accessing body will cause error as its consumed in streaming.
+  */
+ export function fetchLineDelimitedChunks(xhr, url, slotCallback, opt_init) {
+   return xhr.fetch(url, opt_init)
+     .then(response => {
+       let metadata;
+       let snippet = '';
+       const chunkCallback = (chunk, done) => {
+         const regex = /([^\n]*)(\n)?/g;
+         let match;
+         while ((match = regex.exec(chunk))) {
+           snippet += match[1];
+           if (match[2]) {
+             if (metadata) {
+               slotCallback(unescapeHtml_(snippet), metadata,
+                  done && regex.lastIndex === chunk.length);
+               metadata = undefined;
+             } else {
+               metadata = safeJsonParse_(snippet);
+             }
+             snippet = '';
+           }
+           if (regex.lastIndex === chunk.length) {
+             break;
+           }
+         }
+       };
+       if (!response.body || !xhr.win.TextDecoder) {
+         // TODO(keithwrightbos) - TextDecoder polyfill?
+         response.text().then(content => chunkCallback(content, true));
+       } else {
+         handleFetchResponseStream_(
+           response.body.getReader(), chunkCallback, new TextDecoder('utf-8'));
+       }
+       return {status: response.status, headers: response.headers};
+     });
+ }
+
+ /**
+  * @param {!ReadableStreamReader} reader The reader of the fetch's
+  *  response stream.
+  * @param {!function(string, boolean)} chunkHandler
+  * @param {!TextDecoder} textDecoder
+  * @private
+  */
+ function handleFetchResponseStream_(reader, chunkHandler, textDecoder) {
+   reader.read().then(function chunk(result) {
+     if (result.value) {
+       chunkHandler(
+         textDecoder.decode(
+           /** @type {!ArrayBuffer} */(result.value), {'stream': true}),
+         result.done);
+     }
+     if (!result.done) {
+       // More chunks to read.
+       reader.read().then(chunk);
+     }
+   });
+ }
+
+ /**
+  * Unescapes characters that are escaped in line-delimited JSON-HTML.
+  * @param {string} html An html snippet.
+  * @return {string}
+  * @private
+  */
+ function unescapeHtml_(html) {
+   return html ? html.replace(
+     /\\(n|r|\\)/g,
+     (_, match) => match == 'n' ? '\n' : match == 'r' ? '\r' : '\\') : html;
+ }
+
+ /**
+  * @param {string} rawString to be parsed
+  * @return {!Object<string, *>} JSON parsed string or empty object if invalid.
+  * @private
+  */
+ function safeJsonParse_(rawString) {
+   try {
+     const result = JSON.parse(rawString);
+     dev().assert(isObject(result));
+     return /** @type {!Object<string,*>} */(result);
+   } catch (err) {
+     return {};
+   }
+ }

ads/google/a4a/test/test-line-delimited-response-handler.js

@@ -0,0 +1,201 @@
+/**
+ * Copyright 2017 The AMP HTML Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS-IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {fetchLineDelimitedChunks} from '../line-delimited-response-handler';
+import * as sinon from 'sinon';
+
+describe('#line-delimited-response-handler', () => {
+
+  const url = 'https://someadnetwork.com?who=me&yes=you';
+  const xhrInit = {
+    mode: 'cors',
+    method: 'GET',
+    credentials: 'include',
+  };
+  let fetchStub;
+  let chunkHandlerStub;
+  let slotData;
+  let xhr;
+
+  /**
+   * @param {!Array<!{{creative:string,headers:!Object<string,string>}}>} slotData
+   * @return {string} slot data written in expected stream response format
+   */
+  function generateResponseFormat() {
+    let slotDataString = '';
+    slotData.forEach(slot => {
+      // TODO: escape creative returns
+      const creative = slot.creative.replace(/\\/g, '\\\\')
+        .replace(/\n/g, '\\n').replace(/\r/g, '\\r');
+      slotDataString += `${JSON.stringify(slot.headers)}\n${creative}\n`;
+    });
+    return slotDataString;
+  }
+
+  function executeAndVerifyResponse() {
+    // Streamed response calls chunk handlers after returning so need to
+    // wait on chunks.
+    let chunkResolver;
+    const chunkPromise = new Promise(resolver => chunkResolver = resolver);
+    const chunkHandlerWrapper = (creative, metaData) => {
+      chunkHandlerStub(creative, metaData);
+      if (chunkHandlerStub.callCount == slotData.length) {
+        chunkResolver();
+      }
+    };
+    // If no slots then callback will never execute so we need to resolve
+    // immediately.
+    if (slotData.length == 0) {
+      chunkResolver();
+    }
+    return Promise.all([
+      fetchLineDelimitedChunks(xhr, url, chunkHandlerWrapper, xhrInit),
+      chunkPromise,
+    ])
+    .then(results => {
+      // results[0] is the response
+      expect(results[0]).to.be.ok;
+      expect(chunkHandlerStub.callCount).to.equal(slotData.length);
+      // Could have duplicate responses so need to iterate and get counts.
+      // TODO: can't use objects as keys :(
+      const calls = {};
+      slotData.forEach(slot => {
+        const key = slot.creative + JSON.stringify(slot.headers);
+        calls[key] ? calls[key]++ : (calls[key] = 1);
+      });
+      slotData.forEach(slot => {
+        expect(chunkHandlerStub.withArgs(slot.creative, slot.headers).callCount)
+          .to.equal(calls[slot.creative + JSON.stringify(slot.headers)]);
+      });
+    });
+  }
+
+  beforeEach(() => {
+    fetchStub = sinon.stub();
+    chunkHandlerStub = sinon.stub();
+  });
+
+  describe('stream not supported', () => {
+    beforeEach(() => {
+      fetchStub.returns(Promise.resolve({
+        text: () => Promise.resolve(generateResponseFormat()),
+      }));
+      xhr = {
+        fetch: fetchStub,
+        win: {
+          // TextDecoder should exist but not be called
+          TextDecoder: () => { throw new Error('fail'); },
+        },
+      };
+    });
+
+    it('should fallback to text if no stream support', () => {
+      slotData = [
+        {headers: {foo: 'bar'}, creative: '<html>baz\n</html>'},
+        {headers: {hello: 'world'}, creative: '<html>do not\n chunk me</html>'},
+      ];
+      return executeAndVerifyResponse();
+    });
+
+    it('should fallback to text if no stream support w/ empty response', () => {
+      slotData = [];
+      return executeAndVerifyResponse();
+    });
+
+    it('should fallback to text if no TextDecoder', () => {
+      slotData = [
+        {headers: {foo: 'bar', hello: 'world'}, creative: '<html>baz\n</html>'},
+        {headers: {hello: 'world'},
+          creative: '\r\n<html>\nchunk\b me</html>\r\b\n\r'},
+        {headers: {foo: 'bar'}, creative: ''},
+        {headers: {}, creative: '\r\n\r\b\n\r'},
+      ];
+      return executeAndVerifyResponse();
+    });
+  });
+
+  describe('streaming', () => {
+    let readStub;
+
+    function setup() {
+      const responseString = generateResponseFormat();
+      const textEncoder = new TextEncoder('utf-8');
+      const CHUNK_SIZE = 5;
+      let chunk = 0;
+      do {
+        const value = textEncoder.encode(responseString.substr(
+          chunk * CHUNK_SIZE, CHUNK_SIZE), {'stream': true});
+        const done = chunk * CHUNK_SIZE >= responseString.length - 1;
+        readStub.onCall(chunk).returns(Promise.resolve({value, done}));
+      } while (chunk++ * CHUNK_SIZE < responseString.length);
+    }
+
+    beforeEach(() => {
+      readStub = sinon.stub();
+      fetchStub.returns(Promise.resolve({
+        text: () => Promise.resolve(),
+        body: {
+          getReader: () => {
+            return {
+              read: readStub,
+            };
+          },
+        },
+      }));
+      xhr = {
+        fetch: fetchStub,
+        win: {
+          TextDecoder,
+        },
+      };
+    });
+
+    it('should handle empty streamed response properly', () => {
+      slotData = [];
+      setup();
+      return executeAndVerifyResponse();
+    });
+
+    it('should handle no fill response properly', () => {
+      slotData = [{headers: {}, creative: ''}];
+      setup();
+      return executeAndVerifyResponse();
+    });
+
+    it('should handle multiple no fill responses properly', () => {
+      slotData = [
+        {headers: {}, creative: ''},
+        {headers: {}, creative: ''},
+      ];
+      setup();
+      return executeAndVerifyResponse();
+    });
+
+    it('should stream properly', () => {
+      slotData = [
+        {headers: {}, creative: ''},
+        {headers: {foo: 'bar', hello: 'world'},
+          creative: '\t\n\r<html>\bbaz\r</html>\n\n'},
+        {headers: {}, creative: ''},
+        {headers: {hello: 'world'},
+          creative: '<html>\nchu\nnk me</h\rtml\n\t>'},
+        {headers: {}, creative: ''},
+      ];
+      setup();
+      return executeAndVerifyResponse();
+    });
+  });
+});

ads/google/a4a/test/test-utils.js

@@ -367,7 +367,7 @@ describe('Google A4A utils', () => {
         const impl = new MockA4AImpl(elem);
         noopMethods(impl, doc, sandbox);
         return fixture.addElement(elem).then(() => {
-          return googleAdUrl(impl, '', 0, [], [], ['789', '098']).then(url1 => {
+          return googleAdUrl(impl, '', 0, {}, ['789', '098']).then(url1 => {
             expect(url1).to.match(/eid=123%2C456%2C789%2C098/);
           });
         });

ads/google/a4a/url-builder.js

@@ -21,7 +21,8 @@ export let QueryParameterDef;
  * Builds a URL from query parameters, truncating to a maximum length if
  * necessary.
  * @param {string} baseUrl scheme, domain, and path for the URL.
- * @param {!Array<!QueryParameterDef>} queryParams query parameters for the URL.
+ * @param {!Object<string,!string|number|null>} queryParams query parameters for
+ *     the URL.
  * @param {number} maxLength length to truncate the URL to if necessary.
  * @param {?QueryParameterDef=} opt_truncationQueryParam query parameter to
  *     append to the URL iff any query parameters were truncated.
@@ -41,13 +42,15 @@ export function buildUrl(
   if (encodedTruncationParam) {
     capacity -= encodedTruncationParam.length + 1;
   }
-  for (let i = 0; i < queryParams.length; i++) {
-    const param = queryParams[i];
-    if (param.value == null || param.value === '') {
+  const keys = Object.keys(queryParams);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const value = queryParams[key];
+    if (value == null || value === '') {
       continue;
     }
-    const encodedNameAndSep = encodeURIComponent(param.name) + '=';
-    const encodedValue = encodeURIComponent(String(param.value));
+    const encodedNameAndSep = encodeURIComponent(key) + '=';
+    const encodedValue = encodeURIComponent(String(value));
     const fullLength = encodedNameAndSep.length + encodedValue.length + 1;
     if (fullLength > capacity) {
       const truncatedValue = encodedValue