From bebc77d01cfbeea91fa4a034984de32c7ada2aa6 Mon Sep 17 00:00:00 2001
From: Mark Conrad <mconrad@lotame.com>
Date: Fri, 11 Dec 2020 10:54:38 -0500
Subject: [PATCH 1/8] Add the root domain check method as a global method added
 for use modules

---
 modules/userId/index.js          | 55 ++++++++++++++++++++++++++++++++
 test/spec/modules/userId_spec.js | 45 ++++++++++++++++++++++++++
 2 files changed, 100 insertions(+)

diff --git a/modules/userId/index.js b/modules/userId/index.js
index f063fbc973b..38bbc364309 100644
--- a/modules/userId/index.js
+++ b/modules/userId/index.js
@@ -315,6 +315,60 @@ function hasGDPRConsent(consentData) {
   return true;
 }
 
+/**
+   * Find the root domain
+   * @param {string|undefined} fullDomain
+   * @return {string}
+   */
+function findRootDomain(fullDomain = document.domain) {
+  if (!coreStorage.cookiesAreEnabled()) {
+    return fullDomain;
+  }
+
+  const domainParts = fullDomain.split('.');
+  if (domainParts.length == 2) {
+    return fullDomain;
+  }
+  let rootDomain;
+  let continueSearching;
+  let startIndex = -2;
+  const TEST_COOKIE_NAME = '_rdc';
+  const TEST_COOKIE_VALUE = 'writeable';
+  do {
+    rootDomain = domainParts.slice(startIndex).join('.');
+    let expirationDate = new Date(utils.timestamp() + 10 * 1000).toUTCString();
+
+    // Write a test cookie
+    coreStorage.setCookie(
+      TEST_COOKIE_NAME,
+      TEST_COOKIE_VALUE,
+      expirationDate,
+      'Lax',
+      rootDomain,
+      undefined
+    );
+
+    // See if the write was successful
+    const value = coreStorage.getCookie(TEST_COOKIE_NAME, undefined);
+    if (value === TEST_COOKIE_VALUE) {
+      continueSearching = false;
+      // Delete our test cookie
+      coreStorage.setCookie(
+        TEST_COOKIE_NAME,
+        '',
+        'Thu, 01 Jan 1970 00:00:01 GMT',
+        undefined,
+        rootDomain,
+        undefined
+      );
+    } else {
+      startIndex += -1;
+      continueSearching = Math.abs(startIndex) <= domainParts.length;
+    }
+  } while (continueSearching);
+  return rootDomain;
+}
+
 /**
  * @param {SubmoduleContainer[]} submodules
  * @param {function} cb - callback for after processing is done.
@@ -727,6 +781,7 @@ export function init(config) {
   (getGlobal()).getUserIds = getUserIds;
   (getGlobal()).getUserIdsAsEids = getUserIdsAsEids;
   (getGlobal()).refreshUserIds = refreshUserIds;
+  (getGlobal()).findRootDomain = findRootDomain;
 }
 
 // init config update listener to start the application
diff --git a/test/spec/modules/userId_spec.js b/test/spec/modules/userId_spec.js
index 981ebb5f50e..ef9089dc142 100644
--- a/test/spec/modules/userId_spec.js
+++ b/test/spec/modules/userId_spec.js
@@ -410,6 +410,51 @@ describe('User ID', function () {
     });
   });
 
+  describe('findRootDomain', function () {
+    let sandbox;
+
+    beforeEach(function () {
+      setSubmoduleRegistry([pubCommonIdSubmodule]);
+      init(config);
+      config.setConfig({
+        userSync: {
+          syncDelay: 0,
+          userIds: [
+            {
+              name: 'pubCommonId',
+              value: { pubcid: '11111' },
+            },
+          ],
+        },
+      });
+      sandbox = sinon.createSandbox()
+      sandbox
+        .stub(coreStorage, 'getCookie')
+        .onFirstCall()
+        .returns(null) // .co.uk
+        .onSecondCall()
+        .returns('writeable'); // realdomain.co.uk;
+    });
+
+    afterEach(function() {
+      sandbox.restore();
+    })
+
+    it('should be a global function', function() {
+      expect(typeof (getGlobal()).findRootDomain).to.equal('function');
+    })
+
+    it('should just find the root domain', function () {
+      var domain = getGlobal().findRootDomain('sub.realdomain.co.uk');
+      expect(domain).to.be.eq('realdomain.co.uk');
+    });
+
+    it('should find the full domain when no subdomain is present', function () {
+      var domain = getGlobal().findRootDomain('realdomain.co.uk');
+      expect(domain).to.be.eq('realdomain.co.uk');
+    });
+  });
+
   describe('Opt out', function () {
     before(function () {
       coreStorage.setCookie(PBJS_USER_ID_OPTOUT_NAME, '1', (new Date(Date.now() + 5000).toUTCString()));

From f32b59954351d29c869e75c79991da1175db6a05 Mon Sep 17 00:00:00 2001
From: Mark Conrad <mconrad@lotame.com>
Date: Fri, 11 Dec 2020 14:58:04 -0500
Subject: [PATCH 2/8] Add a date suffix to keep the test cookie random

---
 modules/userId/index.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/userId/index.js b/modules/userId/index.js
index 38bbc364309..5a5f45161c2 100644
--- a/modules/userId/index.js
+++ b/modules/userId/index.js
@@ -332,7 +332,7 @@ function findRootDomain(fullDomain = document.domain) {
   let rootDomain;
   let continueSearching;
   let startIndex = -2;
-  const TEST_COOKIE_NAME = '_rdc';
+  const TEST_COOKIE_NAME = `_rdc${Date.now()}`;
   const TEST_COOKIE_VALUE = 'writeable';
   do {
     rootDomain = domainParts.slice(startIndex).join('.');

From 0672f2bdd0d7cd296a5e806845ededa12d55fdc0 Mon Sep 17 00:00:00 2001
From: Mark Conrad <mconrad@lotame.com>
Date: Wed, 16 Dec 2020 09:33:42 -0500
Subject: [PATCH 3/8] Per review, moved the findRootDomain method to utils out
 of the userId modules

---
 modules/userId/index.js          | 55 -------------------------------
 src/utils.js                     | 56 ++++++++++++++++++++++++++++++++
 test/spec/modules/userId_spec.js | 45 -------------------------
 test/spec/utils_spec.js          | 28 ++++++++++++++++
 4 files changed, 84 insertions(+), 100 deletions(-)

diff --git a/modules/userId/index.js b/modules/userId/index.js
index 5a5f45161c2..f063fbc973b 100644
--- a/modules/userId/index.js
+++ b/modules/userId/index.js
@@ -315,60 +315,6 @@ function hasGDPRConsent(consentData) {
   return true;
 }
 
-/**
-   * Find the root domain
-   * @param {string|undefined} fullDomain
-   * @return {string}
-   */
-function findRootDomain(fullDomain = document.domain) {
-  if (!coreStorage.cookiesAreEnabled()) {
-    return fullDomain;
-  }
-
-  const domainParts = fullDomain.split('.');
-  if (domainParts.length == 2) {
-    return fullDomain;
-  }
-  let rootDomain;
-  let continueSearching;
-  let startIndex = -2;
-  const TEST_COOKIE_NAME = `_rdc${Date.now()}`;
-  const TEST_COOKIE_VALUE = 'writeable';
-  do {
-    rootDomain = domainParts.slice(startIndex).join('.');
-    let expirationDate = new Date(utils.timestamp() + 10 * 1000).toUTCString();
-
-    // Write a test cookie
-    coreStorage.setCookie(
-      TEST_COOKIE_NAME,
-      TEST_COOKIE_VALUE,
-      expirationDate,
-      'Lax',
-      rootDomain,
-      undefined
-    );
-
-    // See if the write was successful
-    const value = coreStorage.getCookie(TEST_COOKIE_NAME, undefined);
-    if (value === TEST_COOKIE_VALUE) {
-      continueSearching = false;
-      // Delete our test cookie
-      coreStorage.setCookie(
-        TEST_COOKIE_NAME,
-        '',
-        'Thu, 01 Jan 1970 00:00:01 GMT',
-        undefined,
-        rootDomain,
-        undefined
-      );
-    } else {
-      startIndex += -1;
-      continueSearching = Math.abs(startIndex) <= domainParts.length;
-    }
-  } while (continueSearching);
-  return rootDomain;
-}
-
 /**
  * @param {SubmoduleContainer[]} submodules
  * @param {function} cb - callback for after processing is done.
@@ -781,7 +727,6 @@ export function init(config) {
   (getGlobal()).getUserIds = getUserIds;
   (getGlobal()).getUserIdsAsEids = getUserIdsAsEids;
   (getGlobal()).refreshUserIds = refreshUserIds;
-  (getGlobal()).findRootDomain = findRootDomain;
 }
 
 // init config update listener to start the application
diff --git a/src/utils.js b/src/utils.js
index acdf0f101ad..762f620d00c 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -3,6 +3,7 @@ import { config } from './config.js';
 import clone from 'just-clone';
 import find from 'core-js-pure/features/array/find.js';
 import includes from 'core-js-pure/features/array/includes.js';
+import { getCoreStorageManager } from './storageManager.js';
 
 const CONSTANTS = require('./constants.json');
 
@@ -22,6 +23,7 @@ let consoleInfoExists = Boolean(consoleExists && window.console.info);
 let consoleWarnExists = Boolean(consoleExists && window.console.warn);
 let consoleErrorExists = Boolean(consoleExists && window.console.error);
 var events = require('./events.js');
+export const coreStorage = getCoreStorageManager('util');
 
 // this allows stubbing of utility functions that are used internally by other utility functions
 export const internal = {
@@ -1270,3 +1272,57 @@ export function cyrb53Hash(str, seed = 0) {
   h2 = imul(h2 ^ (h2 >>> 16), 2246822507) ^ imul(h1 ^ (h1 >>> 13), 3266489909);
   return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString();
 }
+
+/**
+   * Find the root domain
+   * @param {string|undefined} fullDomain
+   * @return {string}
+   */
+export function findRootDomain(fullDomain = window.location.hostname) {
+  if (!coreStorage.cookiesAreEnabled()) {
+    return fullDomain;
+  }
+
+  const domainParts = fullDomain.split('.');
+  if (domainParts.length == 2) {
+    return fullDomain;
+  }
+  let rootDomain;
+  let continueSearching;
+  let startIndex = -2;
+  const TEST_COOKIE_NAME = `_rdc${Date.now()}`;
+  const TEST_COOKIE_VALUE = 'writeable';
+  do {
+    rootDomain = domainParts.slice(startIndex).join('.');
+    let expirationDate = new Date(timestamp() + 10 * 1000).toUTCString();
+
+    // Write a test cookie
+    coreStorage.setCookie(
+      TEST_COOKIE_NAME,
+      TEST_COOKIE_VALUE,
+      expirationDate,
+      'Lax',
+      rootDomain,
+      undefined
+    );
+
+    // See if the write was successful
+    const value = coreStorage.getCookie(TEST_COOKIE_NAME, undefined);
+    if (value === TEST_COOKIE_VALUE) {
+      continueSearching = false;
+      // Delete our test cookie
+      coreStorage.setCookie(
+        TEST_COOKIE_NAME,
+        '',
+        'Thu, 01 Jan 1970 00:00:01 GMT',
+        undefined,
+        rootDomain,
+        undefined
+      );
+    } else {
+      startIndex += -1;
+      continueSearching = Math.abs(startIndex) <= domainParts.length;
+    }
+  } while (continueSearching);
+  return rootDomain;
+}
diff --git a/test/spec/modules/userId_spec.js b/test/spec/modules/userId_spec.js
index ef9089dc142..981ebb5f50e 100644
--- a/test/spec/modules/userId_spec.js
+++ b/test/spec/modules/userId_spec.js
@@ -410,51 +410,6 @@ describe('User ID', function () {
     });
   });
 
-  describe('findRootDomain', function () {
-    let sandbox;
-
-    beforeEach(function () {
-      setSubmoduleRegistry([pubCommonIdSubmodule]);
-      init(config);
-      config.setConfig({
-        userSync: {
-          syncDelay: 0,
-          userIds: [
-            {
-              name: 'pubCommonId',
-              value: { pubcid: '11111' },
-            },
-          ],
-        },
-      });
-      sandbox = sinon.createSandbox()
-      sandbox
-        .stub(coreStorage, 'getCookie')
-        .onFirstCall()
-        .returns(null) // .co.uk
-        .onSecondCall()
-        .returns('writeable'); // realdomain.co.uk;
-    });
-
-    afterEach(function() {
-      sandbox.restore();
-    })
-
-    it('should be a global function', function() {
-      expect(typeof (getGlobal()).findRootDomain).to.equal('function');
-    })
-
-    it('should just find the root domain', function () {
-      var domain = getGlobal().findRootDomain('sub.realdomain.co.uk');
-      expect(domain).to.be.eq('realdomain.co.uk');
-    });
-
-    it('should find the full domain when no subdomain is present', function () {
-      var domain = getGlobal().findRootDomain('realdomain.co.uk');
-      expect(domain).to.be.eq('realdomain.co.uk');
-    });
-  });
-
   describe('Opt out', function () {
     before(function () {
       coreStorage.setCookie(PBJS_USER_ID_OPTOUT_NAME, '1', (new Date(Date.now() + 5000).toUTCString()));
diff --git a/test/spec/utils_spec.js b/test/spec/utils_spec.js
index 6494ead78e7..9e6f83a2947 100644
--- a/test/spec/utils_spec.js
+++ b/test/spec/utils_spec.js
@@ -1197,5 +1197,33 @@ describe('Utils', function () {
         expect(typeof utils.cyrb53Hash(stringOne)).to.equal('string');
       });
     });
+
+    describe('findRootDomain', function () {
+      let sandbox;
+
+      beforeEach(function () {
+        sandbox = sinon.createSandbox();
+        sandbox
+          .stub(utils.coreStorage, 'getCookie')
+          .onFirstCall()
+          .returns(null) // .co.uk
+          .onSecondCall()
+          .returns('writeable'); // realdomain.co.uk;
+      });
+
+      afterEach(function () {
+        sandbox.restore();
+      });
+
+      it('should just find the root domain', function () {
+        var domain = utils.findRootDomain('sub.realdomain.co.uk');
+        expect(domain).to.be.eq('realdomain.co.uk');
+      });
+
+      it('should find the full domain when no subdomain is present', function () {
+        var domain = utils.findRootDomain('realdomain.co.uk');
+        expect(domain).to.be.eq('realdomain.co.uk');
+      });
+    });
   });
 });

From 47ec3b2ac158b8f2a2ff97ef021e4799a521ca90 Mon Sep 17 00:00:00 2001
From: Mark Conrad <mconrad@lotame.com>
Date: Thu, 7 Jan 2021 15:45:46 -0500
Subject: [PATCH 4/8] More the domain method back the user module but attach it
 to the submodule so that userId modules can have access to it

---
 integrationExamples/gpt/userId_example.html |  3 +-
 modules/userId/index.js                     | 69 +++++++++++++++++++++
 src/utils.js                                | 54 ----------------
 test/spec/modules/userId_spec.js            | 46 +++++++++++++-
 test/spec/utils_spec.js                     | 28 ---------
 5 files changed, 116 insertions(+), 84 deletions(-)

diff --git a/integrationExamples/gpt/userId_example.html b/integrationExamples/gpt/userId_example.html
index e6f9255326a..fa9b1e3b5fd 100644
--- a/integrationExamples/gpt/userId_example.html
+++ b/integrationExamples/gpt/userId_example.html
@@ -109,6 +109,7 @@
         <script src="../../build/dev/prebid.js" async></script>
 
         <script>
+            function getHashedEmail() {}
             var googletag = googletag || {};
             googletag.cmd = googletag.cmd || [];
             googletag.cmd.push(function() {
@@ -157,7 +158,7 @@
                                         }
                                     }]
                                 }],
-                                eidsFunction: getHashedEmail  // any user defined function that exists in the page
+                                eidsFunction: getHashedEmail // any user defined function that exists in the page
                             }
                         },{
                             name: "unifiedId",
diff --git a/modules/userId/index.js b/modules/userId/index.js
index f063fbc973b..9294311de69 100644
--- a/modules/userId/index.js
+++ b/modules/userId/index.js
@@ -48,6 +48,20 @@
  * @type {string}
  */
 
+/**
+ * @property
+ * @summary use a predefined domain override for cookies or provide your own
+ * @name Submodule#domainOverride
+ * @type {(undefined|function)}
+ */
+
+/**
+ * @function
+ * @summary Returns the root domain
+ * @name Submodule#findRootDomain
+ * @returns {string}
+ */
+
 /**
  * @typedef {Object} SubmoduleConfig
  * @property {string} name - the User ID submodule name (used to link submodule with config)
@@ -315,6 +329,60 @@ function hasGDPRConsent(consentData) {
   return true;
 }
 
+/**
+   * Find the root domain
+   * @param {string|undefined} fullDomain
+   * @return {string}
+   */
+export function findRootDomain(fullDomain = window.location.hostname) {
+  if (!coreStorage.cookiesAreEnabled()) {
+    return fullDomain;
+  }
+
+  const domainParts = fullDomain.split('.');
+  if (domainParts.length == 2) {
+    return fullDomain;
+  }
+  let rootDomain;
+  let continueSearching;
+  let startIndex = -2;
+  const TEST_COOKIE_NAME = `_rdc${Date.now()}`;
+  const TEST_COOKIE_VALUE = 'writeable';
+  do {
+    rootDomain = domainParts.slice(startIndex).join('.');
+    let expirationDate = new Date(utils.timestamp() + 10 * 1000).toUTCString();
+
+    // Write a test cookie
+    coreStorage.setCookie(
+      TEST_COOKIE_NAME,
+      TEST_COOKIE_VALUE,
+      expirationDate,
+      'Lax',
+      rootDomain,
+      undefined
+    );
+
+    // See if the write was successful
+    const value = coreStorage.getCookie(TEST_COOKIE_NAME, undefined);
+    if (value === TEST_COOKIE_VALUE) {
+      continueSearching = false;
+      // Delete our test cookie
+      coreStorage.setCookie(
+        TEST_COOKIE_NAME,
+        '',
+        'Thu, 01 Jan 1970 00:00:01 GMT',
+        undefined,
+        rootDomain,
+        undefined
+      );
+    } else {
+      startIndex += -1;
+      continueSearching = Math.abs(startIndex) <= domainParts.length;
+    }
+  } while (continueSearching);
+  return rootDomain;
+}
+
 /**
  * @param {SubmoduleContainer[]} submodules
  * @param {function} cb - callback for after processing is done.
@@ -657,6 +725,7 @@ function updateSubmodules() {
   // find submodule and the matching configuration, if found create and append a SubmoduleContainer
   submodules = addedSubmodules.map(i => {
     const submoduleConfig = find(configs, j => j.name === i.name);
+    i.findRootDomain = findRootDomain;
     return submoduleConfig ? {
       submodule: i,
       config: submoduleConfig,
diff --git a/src/utils.js b/src/utils.js
index 762f620d00c..105224dcbdb 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -1272,57 +1272,3 @@ export function cyrb53Hash(str, seed = 0) {
   h2 = imul(h2 ^ (h2 >>> 16), 2246822507) ^ imul(h1 ^ (h1 >>> 13), 3266489909);
   return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString();
 }
-
-/**
-   * Find the root domain
-   * @param {string|undefined} fullDomain
-   * @return {string}
-   */
-export function findRootDomain(fullDomain = window.location.hostname) {
-  if (!coreStorage.cookiesAreEnabled()) {
-    return fullDomain;
-  }
-
-  const domainParts = fullDomain.split('.');
-  if (domainParts.length == 2) {
-    return fullDomain;
-  }
-  let rootDomain;
-  let continueSearching;
-  let startIndex = -2;
-  const TEST_COOKIE_NAME = `_rdc${Date.now()}`;
-  const TEST_COOKIE_VALUE = 'writeable';
-  do {
-    rootDomain = domainParts.slice(startIndex).join('.');
-    let expirationDate = new Date(timestamp() + 10 * 1000).toUTCString();
-
-    // Write a test cookie
-    coreStorage.setCookie(
-      TEST_COOKIE_NAME,
-      TEST_COOKIE_VALUE,
-      expirationDate,
-      'Lax',
-      rootDomain,
-      undefined
-    );
-
-    // See if the write was successful
-    const value = coreStorage.getCookie(TEST_COOKIE_NAME, undefined);
-    if (value === TEST_COOKIE_VALUE) {
-      continueSearching = false;
-      // Delete our test cookie
-      coreStorage.setCookie(
-        TEST_COOKIE_NAME,
-        '',
-        'Thu, 01 Jan 1970 00:00:01 GMT',
-        undefined,
-        rootDomain,
-        undefined
-      );
-    } else {
-      startIndex += -1;
-      continueSearching = Math.abs(startIndex) <= domainParts.length;
-    }
-  } while (continueSearching);
-  return rootDomain;
-}
diff --git a/test/spec/modules/userId_spec.js b/test/spec/modules/userId_spec.js
index 981ebb5f50e..9eace12cd2b 100644
--- a/test/spec/modules/userId_spec.js
+++ b/test/spec/modules/userId_spec.js
@@ -8,7 +8,8 @@ import {
   setStoredValue,
   setSubmoduleRegistry,
   syncDelay,
-  PBJS_USER_ID_OPTOUT_NAME
+  PBJS_USER_ID_OPTOUT_NAME,
+  findRootDomain,
 } from 'modules/userId/index.js';
 import {createEidsArray} from 'modules/userId/eids.js';
 import {config} from 'src/config.js';
@@ -2145,6 +2146,8 @@ describe('User ID', function () {
     let coreStorageSpy;
     beforeEach(function () {
       coreStorageSpy = sinon.spy(coreStorage, 'setCookie');
+      setSubmoduleRegistry([pubCommonIdSubmodule]);
+      init(config);
     });
     afterEach(function () {
       coreStorageSpy.restore();
@@ -2360,5 +2363,46 @@ describe('User ID', function () {
         sinon.assert.calledOnce(mockExtendId);
       });
     });
+
+    describe('findRootDomain', function () {
+      let sandbox;
+
+      beforeEach(function () {
+        setSubmoduleRegistry([pubCommonIdSubmodule]);
+        init(config);
+        config.setConfig({
+          userSync: {
+            syncDelay: 0,
+            userIds: [
+              {
+                name: 'pubCommonId',
+                value: { pubcid: '11111' },
+              },
+            ],
+          },
+        });
+        sandbox = sinon.createSandbox();
+        sandbox
+          .stub(coreStorage, 'getCookie')
+          .onFirstCall()
+          .returns(null) // .co.uk
+          .onSecondCall()
+          .returns('writeable'); // realdomain.co.uk;
+      });
+
+      afterEach(function () {
+        sandbox.restore();
+      });
+
+      it('should just find the root domain', function () {
+        var domain = findRootDomain('sub.realdomain.co.uk');
+        expect(domain).to.be.eq('realdomain.co.uk');
+      });
+
+      it('should find the full domain when no subdomain is present', function () {
+        var domain = findRootDomain('realdomain.co.uk');
+        expect(domain).to.be.eq('realdomain.co.uk');
+      });
+    });
   });
 });
diff --git a/test/spec/utils_spec.js b/test/spec/utils_spec.js
index 9e6f83a2947..6494ead78e7 100644
--- a/test/spec/utils_spec.js
+++ b/test/spec/utils_spec.js
@@ -1197,33 +1197,5 @@ describe('Utils', function () {
         expect(typeof utils.cyrb53Hash(stringOne)).to.equal('string');
       });
     });
-
-    describe('findRootDomain', function () {
-      let sandbox;
-
-      beforeEach(function () {
-        sandbox = sinon.createSandbox();
-        sandbox
-          .stub(utils.coreStorage, 'getCookie')
-          .onFirstCall()
-          .returns(null) // .co.uk
-          .onSecondCall()
-          .returns('writeable'); // realdomain.co.uk;
-      });
-
-      afterEach(function () {
-        sandbox.restore();
-      });
-
-      it('should just find the root domain', function () {
-        var domain = utils.findRootDomain('sub.realdomain.co.uk');
-        expect(domain).to.be.eq('realdomain.co.uk');
-      });
-
-      it('should find the full domain when no subdomain is present', function () {
-        var domain = utils.findRootDomain('realdomain.co.uk');
-        expect(domain).to.be.eq('realdomain.co.uk');
-      });
-    });
   });
 });

From b0204b7de91650d1fb2a58640eef08b562925037 Mon Sep 17 00:00:00 2001
From: Mark Conrad <mconrad@lotame.com>
Date: Fri, 8 Jan 2021 09:26:32 -0500
Subject: [PATCH 5/8] Remove the storageManager as it is no longer used in
 utils

---
 src/utils.js | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/utils.js b/src/utils.js
index 105224dcbdb..acdf0f101ad 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -3,7 +3,6 @@ import { config } from './config.js';
 import clone from 'just-clone';
 import find from 'core-js-pure/features/array/find.js';
 import includes from 'core-js-pure/features/array/includes.js';
-import { getCoreStorageManager } from './storageManager.js';
 
 const CONSTANTS = require('./constants.json');
 
@@ -23,7 +22,6 @@ let consoleInfoExists = Boolean(consoleExists && window.console.info);
 let consoleWarnExists = Boolean(consoleExists && window.console.warn);
 let consoleErrorExists = Boolean(consoleExists && window.console.error);
 var events = require('./events.js');
-export const coreStorage = getCoreStorageManager('util');
 
 // this allows stubbing of utility functions that are used internally by other utility functions
 export const internal = {

From 12a95f22bec2da0b7c24f6b677d28dbc72c88541 Mon Sep 17 00:00:00 2001
From: Mark Conrad <mconrad@lotame.com>
Date: Fri, 8 Jan 2021 16:19:21 -0500
Subject: [PATCH 6/8] lotamePanoramaIdSubmodule: Add root cookie domain to all
 cookie writes

---
 modules/lotamePanoramaIdSystem.js | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/modules/lotamePanoramaIdSystem.js b/modules/lotamePanoramaIdSystem.js
index 5c3a9a16b3a..10014aade57 100644
--- a/modules/lotamePanoramaIdSystem.js
+++ b/modules/lotamePanoramaIdSystem.js
@@ -18,6 +18,7 @@ const DAYS_TO_CACHE = 7;
 const DAY_MS = 60 * 60 * 24 * 1000;
 
 export const storage = getStorageManager(null, MODULE_NAME);
+let cookieDomain;
 
 /**
  * Set the Lotame First Party Profile ID in the first party namespace
@@ -26,7 +27,14 @@ export const storage = getStorageManager(null, MODULE_NAME);
 function setProfileId(profileId) {
   if (storage.cookiesAreEnabled()) {
     let expirationDate = new Date(utils.timestamp() + NINE_MONTHS_MS).toUTCString();
-    storage.setCookie(KEY_PROFILE, profileId, expirationDate, 'Lax', undefined, undefined);
+    storage.setCookie(
+      KEY_PROFILE,
+      profileId,
+      expirationDate,
+      'Lax',
+      cookieDomain,
+      undefined
+    );
   }
   if (storage.hasLocalStorage()) {
     storage.setDataInLocalStorage(KEY_PROFILE, profileId, undefined);
@@ -88,7 +96,7 @@ function saveLotameCache(
         value,
         expirationDate,
         'Lax',
-        undefined,
+        cookieDomain,
         undefined
       );
     }
@@ -115,7 +123,7 @@ function getLotameLocalCache() {
   try {
     const rawExpiry = getFromStorage(KEY_EXPIRY);
     if (utils.isStr(rawExpiry)) {
-      cache.expiryTimestampMs = parseInt(rawExpiry, 0);
+      cache.expiryTimestampMs = parseInt(rawExpiry, 10);
     }
   } catch (error) {
     utils.logError(error);
@@ -132,7 +140,14 @@ function clearLotameCache(key) {
   if (key) {
     if (storage.cookiesAreEnabled()) {
       let expirationDate = new Date(0).toUTCString();
-      storage.setCookie(key, '', expirationDate, 'Lax', undefined, undefined);
+      storage.setCookie(
+        key,
+        '',
+        expirationDate,
+        'Lax',
+        cookieDomain,
+        undefined
+      );
     }
     if (storage.hasLocalStorage()) {
       storage.removeDataFromLocalStorage(key, undefined);
@@ -168,6 +183,7 @@ export const lotamePanoramaIdSubmodule = {
    * @returns {IdResponse|undefined}
    */
   getId(config, consentData, cacheIdObj) {
+    cookieDomain = lotamePanoramaIdSubmodule.findRootDomain();
     let localCache = getLotameLocalCache();
 
     let refreshNeeded = Date.now() > localCache.expiryTimestampMs;

From 95d070d2b05cb8757e7871f52f3a2c511638d025 Mon Sep 17 00:00:00 2001
From: Mark Conrad <mconrad@lotame.com>
Date: Fri, 8 Jan 2021 16:26:14 -0500
Subject: [PATCH 7/8] lotamePanoramaIdSubmodule: Don't update profile id
 storage for a particular error

---
 modules/lotamePanoramaIdSystem.js             |  16 ++-
 .../modules/lotamePanoramaIdSystem_spec.js    | 113 ++++++++++++++++++
 2 files changed, 126 insertions(+), 3 deletions(-)

diff --git a/modules/lotamePanoramaIdSystem.js b/modules/lotamePanoramaIdSystem.js
index 10014aade57..313e9a60925 100644
--- a/modules/lotamePanoramaIdSystem.js
+++ b/modules/lotamePanoramaIdSystem.js
@@ -16,6 +16,7 @@ const MODULE_NAME = 'lotamePanoramaId';
 const NINE_MONTHS_MS = 23328000 * 1000;
 const DAYS_TO_CACHE = 7;
 const DAY_MS = 60 * 60 * 24 * 1000;
+const MISSING_CORE_CONSENT = 111;
 
 export const storage = getStorageManager(null, MODULE_NAME);
 let cookieDomain;
@@ -221,10 +222,17 @@ export const lotamePanoramaIdSubmodule = {
           if (response) {
             try {
               let responseObj = JSON.parse(response);
-              saveLotameCache(KEY_EXPIRY, responseObj.expiry_ts);
+              const shouldUpdateProfileId = !(
+                utils.isArray(responseObj.errors) &&
+                responseObj.errors.includes(MISSING_CORE_CONSENT)
+              );
+
+              saveLotameCache(KEY_EXPIRY, responseObj.expiry_ts, responseObj.expiry_ts);
 
               if (utils.isStr(responseObj.profile_id)) {
-                setProfileId(responseObj.profile_id);
+                if (shouldUpdateProfileId) {
+                  setProfileId(responseObj.profile_id);
+                }
 
                 if (utils.isStr(responseObj.core_id)) {
                   saveLotameCache(
@@ -237,7 +245,9 @@ export const lotamePanoramaIdSubmodule = {
                   clearLotameCache(KEY_ID);
                 }
               } else {
-                clearLotameCache(KEY_PROFILE);
+                if (shouldUpdateProfileId) {
+                  clearLotameCache(KEY_PROFILE);
+                }
                 clearLotameCache(KEY_ID);
               }
             } catch (error) {
diff --git a/test/spec/modules/lotamePanoramaIdSystem_spec.js b/test/spec/modules/lotamePanoramaIdSystem_spec.js
index c6d3383374a..0362aeb912f 100644
--- a/test/spec/modules/lotamePanoramaIdSystem_spec.js
+++ b/test/spec/modules/lotamePanoramaIdSystem_spec.js
@@ -446,4 +446,117 @@ describe('LotameId', function() {
       'lotamePanoramaId': '1234'
     });
   });
+
+  describe('with an empty cache, ignore profile id for error 111', function () {
+    let request;
+    let callBackSpy = sinon.spy();
+
+    beforeEach(function () {
+      let submoduleCallback = lotamePanoramaIdSubmodule.getId({}).callback;
+      submoduleCallback(callBackSpy);
+
+      request = server.requests[0];
+
+      request.respond(
+        200,
+        responseHeader,
+        JSON.stringify({
+          profile_id: '4ec137245858469eb94a4e248f238694',
+          expiry_ts: 10,
+          errors: [111],
+          core_id:
+            'ca22992567e3cd4d116a5899b88a55d0d857a23610db939ae6ac13ba2335d87a',
+        })
+      );
+    });
+
+    it('should not save the first party id', function () {
+      sinon.assert.neverCalledWith(
+        setLocalStorageStub,
+        '_cc_id',
+        '4ec137245858469eb94a4e248f238694'
+      );
+      sinon.assert.neverCalledWith(
+        setCookieStub,
+        '_cc_id',
+        '4ec137245858469eb94a4e248f238694'
+      );
+    });
+
+    it('should save the expiry', function () {
+      sinon.assert.calledWith(setLocalStorageStub, 'panoramaId_expiry', 10);
+
+      sinon.assert.calledWith(setCookieStub, 'panoramaId_expiry', 10);
+    });
+
+    it('should save the id', function () {
+      sinon.assert.calledWith(
+        setLocalStorageStub,
+        'panoramaId',
+        'ca22992567e3cd4d116a5899b88a55d0d857a23610db939ae6ac13ba2335d87a'
+      );
+
+      sinon.assert.calledWith(
+        setCookieStub,
+        'panoramaId',
+        'ca22992567e3cd4d116a5899b88a55d0d857a23610db939ae6ac13ba2335d87a'
+      );
+    });
+  });
+
+  describe('receives an optout request with an error 111', function () {
+    let request;
+    let callBackSpy = sinon.spy();
+
+    beforeEach(function () {
+      getCookieStub.withArgs('panoramaId_expiry').returns('1000');
+      getCookieStub
+        .withArgs('panoramaId')
+        .returns(
+          'ca22992567e3cd4d116a5899b88a55d0d857a23610db939ae6ac13ba2335d87d'
+        );
+
+      let submoduleCallback = lotamePanoramaIdSubmodule.getId({}).callback;
+      submoduleCallback(callBackSpy);
+
+      request = server.requests[0];
+
+      request.respond(
+        200,
+        responseHeader,
+        JSON.stringify({
+          errors: [111],
+          expiry_ts: Date.now() + 30 * 24 * 60 * 60 * 1000,
+        })
+      );
+    });
+
+    it('should call the remote server when getId is called', function () {
+      expect(callBackSpy.calledOnce).to.be.true;
+    });
+
+    it('should clear the panorama id', function () {
+      sinon.assert.calledWith(removeFromLocalStorageStub, 'panoramaId');
+
+      sinon.assert.calledWith(
+        setCookieStub,
+        'panoramaId',
+        '',
+        'Thu, 01 Jan 1970 00:00:00 GMT',
+        'Lax'
+      );
+    });
+
+    it('should not clear the profile id', function () {
+      sinon.assert.neverCalledWith(removeFromLocalStorageStub, '_cc_id');
+
+      sinon.assert.neverCalledWith(
+        setCookieStub,
+        '_cc_id',
+        '',
+        'Thu, 01 Jan 1970 00:00:00 GMT',
+        'Lax'
+      );
+    });
+  });
 });

From a540fe874dc81ec9fcf989e9d1ebc8493bd4c774 Mon Sep 17 00:00:00 2001
From: Mark Conrad <mconrad@lotame.com>
Date: Thu, 14 Jan 2021 10:05:22 -0500
Subject: [PATCH 8/8] lotamePanoramaIdSystem: Switch to indexOf instead of
 includes to support IE 11

---
 modules/lotamePanoramaIdSystem.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/lotamePanoramaIdSystem.js b/modules/lotamePanoramaIdSystem.js
index 457739aa8da..fbfbf390902 100644
--- a/modules/lotamePanoramaIdSystem.js
+++ b/modules/lotamePanoramaIdSystem.js
@@ -230,7 +230,7 @@ export const lotamePanoramaIdSubmodule = {
               let responseObj = JSON.parse(response);
               const shouldUpdateProfileId = !(
                 utils.isArray(responseObj.errors) &&
-                responseObj.errors.includes(MISSING_CORE_CONSENT)
+                responseObj.errors.indexOf(MISSING_CORE_CONSENT) !== -1
               );
 
               saveLotameCache(KEY_EXPIRY, responseObj.expiry_ts, responseObj.expiry_ts);