[IDBObservers] Moving options from constructor to .observe call.

third_party/WebKit/LayoutTests/storage/indexeddb/resources/observer-tests.js

 if (this.importScripts) {
   importScripts('../../../resources/testharness.js');
   importScripts('generic-idb-operations.js');
   importScripts('observer-helpers.js');
   importScripts('testharness-helpers.js');
 }
 
 setup({timeout: 20000});
 
 var openDB = function(t, dbName, openFunc) {
@@ skipping 15 matching lines @@
     }
   };
   var connection = null;
   var observeFunction = function(changes) {
     compareChanges(changes, expectedChanges);
     assert_true(connection != null);
     obs.unobserve(connection);
     t.done();
   };
 
-  var obs = new IDBObserver(
-      t.step_func(observeFunction),
-      { operationTypes: ['clear', 'put', 'add', 'delete'] });
+  var obs = new IDBObserver(t.step_func(observeFunction));
 
   openDB(t, db1_name, t.step_func(function(db) {
     connection = db;
     var txn = db.transaction(['store1', 'store2'], 'readwrite');
 
     // Verify initial state.
     var os1 = txn.objectStore('store1');
     var readReq1 = os1.get('a');
     readReq1.onsuccess = t.step_func(function() {
       assert_equals(readReq1.result, 'b', 'Initial state incorrect.');
     });
     var os2 = txn.objectStore('store2');
     var readReq2 = os2.get('x');
     readReq2.onsuccess = t.step_func(function() {
       assert_equals(readReq2.result, 'y', 'Initial state incorrect.');
     });
 
     // Start observing!
-    obs.observe(db, txn);
+    obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
 
     txn.oncomplete = observers_added_callback;
     txn.onerror = t.unreached_func('transaction should not fail');
   }));
 }, 'IDB Observers: Verify initial state and record all operations');
 
 indexeddb_observers_test(function(t, db1_name, db2_name, observers_added_callback) {
   var expectedChanges = {
     dbName: db1_name,
     records: {
       'store2': [{type: 'add', key: 'z'}]
     }
   };
 
   var connection = null;
   var observeFunction = function(changes) {
     compareChanges(changes, expectedChanges);
     assert_true(connection != null);
     obs.unobserve(connection);
     t.done();
   };
 
-  var obs = new IDBObserver(
-      t.step_func(observeFunction),
-      { operationTypes: ['add'] });
+  var obs = new IDBObserver(t.step_func(observeFunction));
 
   openDB(t, db1_name, t.step_func(function(db) {
     connection = db;
     var txn = db.transaction(['store2'], 'readonly');
-    obs.observe(db, txn);
+    obs.observe(db, txn, {operationTypes: ['add']});
     txn.oncomplete = observers_added_callback;
     txn.onerror = t.unreached_func('transaction should not fail')
   }));
 }, 'IDB Observers: Operation filtering');
 
 indexeddb_observers_test(function(t, db1_name, db2_name, observers_added_callback) {
   var expectedChanges = {
     dbName: db1_name,
     records: {
       'store2': [{type: 'add', key: 'z'}]
     }
   };
 
   var connection = null;
   var observeFunction = function(changes) {
     compareChanges(changes, expectedChanges);
     assert_true(connection != null);
     obs.unobserve(connection);
     t.done();
   };
 
-  var obs = new IDBObserver(
-      t.step_func(observeFunction),
-      { operationTypes: ['clear', 'put', 'add', 'delete'] });
+  var obs = new IDBObserver(t.step_func(observeFunction));
 
   openDB(t, db1_name, t.step_func(function(db) {
     connection = db;
     var txn = db.transaction(['store2'], 'readonly');
-    obs.observe(db, txn);
+    obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
     txn.oncomplete = observers_added_callback;
     txn.onerror = t.unreached_func('transaction should not fail')
   }));
 }, 'IDB Observers: Object store filtering');
 
 indexeddb_observers_test(function(t, db1_name, db2_name, observers_added_callback) {
   var expectedChanges1 = {
     dbName: db1_name,
     records: {
       'store1': [{type: 'delete', key: {lower: 'a', upper: 'b'}},
@@ skipping 26 matching lines @@
       assert_true(connection2 != null);
       obs.unobserve(connection2);
     }
     if (pendingObserves === 0) {
       t.done();
     } else if (pendingObserves < 0) {
       assert_unreached("incorrect pendingObserves");
     }
   };
 
-  var obs = new IDBObserver(
-      t.step_func(observeFunction),
-      { operationTypes: ['clear', 'put', 'add', 'delete'] });
+  var obs = new IDBObserver(t.step_func(observeFunction));
 
   var cb1 = observers_added_barrier(t);
   openDB(t, db1_name, t.step_func(function(db) {
     connection1 = db;
     var txn = db.transaction(['store1', 'store2'], 'readonly');
-    obs.observe(db, txn);
+    obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
     txn.oncomplete = cb1;
     txn.onerror = t.unreached_func('transaction should not fail')
   }));
   var cb2 = observers_added_barrier(t);
   openDB(t, db2_name, t.step_func(function(db) {
     connection2 = db;
     var txn = db.transaction(['store3', 'store4'], 'readonly');
-    obs.observe(db, txn);
+    obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
     txn.oncomplete = cb2;
     txn.onerror = t.unreached_func('transaction should not fail')
   }));
 }, 'IDB Observers: Multiple connections');
 
 indexeddb_observers_test(function(t, db1_name, db2_name, observers_added_callback) {
   var expectedChanges = {
     dbName: db1_name,
     records: {
       'store1': [{type: 'delete', key: {lower: 'a', upper: 'b'}},
                  {type: 'put', key: 'a'}],
       'store2': [{type: 'add', key: 'z'}]
     }
   };
 
   var connection = null;
   var pendingObserves = 2;
   var observeFunction = function(changes) {
     compareChanges(changes, expectedChanges);
     pendingObserves = pendingObserves - 1;
     if (pendingObserves === 0) {
       assert_true(connection != null);
       obs.unobserve(connection);
       t.done();
     } else if (pendingObserves < 0) {
       assert_unreached("incorrect pendingObserves");
     }
   };
 
-  var obs = new IDBObserver(
-      t.step_func(observeFunction),
-      { operationTypes: ['clear', 'put', 'add', 'delete'] });
+  var obs = new IDBObserver(t.step_func(observeFunction));
 
   openDB(t, db1_name, t.step_func(function(db) {
     connection = db;
     var txn = db.transaction(['store1', 'store2'], 'readonly');
-    obs.observe(db, txn);
-    obs.observe(db, txn);
+    obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});

[cmumford, 2016/11/07 21:55:16]

Makes me wonder if we should have an "all" type.

[dmurph, 2016/11/07 22:31:54]

Yeah -- I wanted it to directly reflect the function calls. Since this is a
low-level-ish api, I'm fine with being a little verbose with the advantage that
it's dead-obvious what is being observed.

+    obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
     txn.oncomplete = observers_added_callback;
     txn.onerror = t.unreached_func('transaction should not fail');
   }));
 }, 'IDB Observers: Multiple observer calls');
 
 indexeddb_observers_test(function(t, db1_name, db2_name, observers_added_callback) {
+  var expectedChanges1 = {
+    dbName: db1_name,
+    records: {
+      'store1': [{type: 'put', key: 'a'}]
+    }
+  };
+  var expectedChanges2 = {
+    dbName: db1_name,
+    records: {
+      'store2': [{type: 'add', key: 'z'}]
+    }
+  };
+
+  var connection = null;
+  var changeNumber = 0;
+  var observeFunction = function(changes) {
+    assert_true(connection != null);
+    if (changeNumber === 0) {
+      compareChanges(changes, expectedChanges1);
+    } else if(changeNumber === 1) {
+      compareChanges(changes, expectedChanges2);
+      obs.unobserve(connection);
+      t.done();
+    }
+    ++changeNumber;
+    if (changeNumber > 1) {

[cmumford, 2016/11/07 21:55:15]

Nit: How about assert_less_than_equal(changeNumber, 1, "incorrect
pendingObserves");

[dmurph, 2016/11/07 22:31:54]

I was looking for that assert! ;) thanks!

+      assert_unreached("incorrect pendingObserves");
+    }
+  };
+
+  var obs = new IDBObserver(t.step_func(observeFunction));
+
+  openDB(t, db1_name, t.step_func(function(db) {
+    connection = db;
+    var txn = db.transaction(['store1', 'store2'], 'readonly');
+    obs.observe(db, txn, {operationTypes: ['put']});
+    obs.observe(db, txn, {operationTypes: ['add']});
+    txn.oncomplete = observers_added_callback;
+    txn.onerror = t.unreached_func('transaction should not fail');
+  }));
+}, 'IDB Observers: Multiple observer calls with filtering');
+
+indexeddb_observers_test(function(t, db1_name, db2_name, observers_added_callback) {
   var partOneChanges1 = {
     dbName: db1_name,
     records: {
       'store1': [{type: 'delete', key: {lower: 'a', upper: 'b'}},
                  {type: 'put', key: 'a'}]
     }
   };
 
   var partOneChanges2 = {
     dbName: db1_name,
@@ skipping 43 matching lines @@
     } else {
       assert_unreached('Unknown connection supplied with changes.');
     }
     if (pendingObserves === 0) {
       t.done();
     } else if (pendingObserves < 0) {
       assert_unreached("incorrect pendingObserves");
     }
   };
 
-  var obs = new IDBObserver(
-      t.step_func(observeFunction),
-      { operationTypes: ['clear', 'put', 'add', 'delete'] });
+  var obs = new IDBObserver(t.step_func(observeFunction));
 
   var cb1 = observers_added_barrier(t);
   openDB(t, db1_name, t.step_func(function(db) {
     connection1 = db;
     var txn = db.transaction(['store1'], 'readonly');
-    obs.observe(db, txn);
+    obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
     txn.oncomplete = cb1;
     txn.onerror = t.unreached_func('transaction should not fail');
   }));
   var cb2 = observers_added_barrier(t);
   openDB(t, db1_name, t.step_func(function(db) {
     connection2 = db;
     var txn = db.transaction(['store2'], 'readonly');
-    obs.observe(db, txn);
+    obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
     txn.oncomplete = cb2;
     txn.onerror = t.unreached_func('transaction should not fail');
   }));
   var cb3 = observers_added_barrier(t);
   openDB(t, db2_name, t.step_func(function(db) {
     connection3 = db;
     var txn = db.transaction(['store3', 'store4'], 'readonly');
-    obs.observe(db, txn);
+    obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
     txn.oncomplete = cb3;
     txn.onerror = t.unreached_func('transaction should not fail')
   }));
 }, 'IDB Observers: Three connections, unobserve two');
 
 indexeddb_observers_test(function(t, db1_name, db2_name, observers_added_callback) {
   var connection1 = null;
   var connection2 = null;
 
   var observeFunction = function(changes) {
     assert_equals(changes.database, connection2);
     obs.unobserve(connection2);
     t.done();
   };
 
-  var obs = new IDBObserver(
-      t.step_func(observeFunction),
-      { operationTypes: ['clear', 'put', 'add', 'delete'] });
+  var obs = new IDBObserver(t.step_func(observeFunction));
 
   openDB(t, db1_name, t.step_func(function(db) {
     connection1 = db;
     var txn = db.transaction(['store1'], 'readonly');
-    obs.observe(db, txn);
+    obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
     obs.unobserve(db);
     txn.oncomplete = t.step_func(function() {
       openDB(t, db1_name, t.step_func(function(db) {
         connection2 = db;
         var txn = db.transaction(['store2'], 'readonly');
-        obs.observe(db, txn);
+        obs.observe(
+            db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
         txn.oncomplete = observers_added_callback;
         txn.onerror = t.unreached_func('transaction should not fail');
       }));
     });
     txn.onerror = t.unreached_func('transaction should not fail');
   }));
 }, 'IDB Observers: Unobserve immediately');
 
 indexeddb_observers_test(function(t, db1_name, db2_name, observers_added_callback) {
   var connection1 = null;
   var connection2 = null;
 
   var observeFunction = function(changes) {
     assert_equals(changes.database, connection2);
     obs.unobserve(connection2);
     t.done();
   };
 
-  var obs = new IDBObserver(
-      t.step_func(observeFunction),
-      { operationTypes: ['clear', 'put', 'add', 'delete'] });
+  var obs = new IDBObserver(t.step_func(observeFunction));
 
   openDB(t, db1_name, t.step_func(function(db) {
     connection1 = db;
     var txn = db.transaction(['store1'], 'readonly');
-    obs.observe(db, txn);
-    obs.observe(db, txn);
-    obs.observe(db, txn);
+    obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
+    obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
+    obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
     obs.unobserve(db);
     txn.oncomplete = t.step_func(function() {
       openDB(t, db1_name, t.step_func(function(db) {
         connection2 = db;
         var txn = db.transaction(['store2'], 'readonly');
-        obs.observe(db, txn);
+        obs.observe(
+            db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
         txn.oncomplete = observers_added_callback;
         txn.onerror = t.unreached_func('transaction should not fail');
       }));
     });
     txn.onerror = t.unreached_func('transaction should not fail');
   }));
 }, 'IDB Observers: Unobserve immediately on multiple');
 
 indexeddb_observers_test(function(t, db1_name, db2_name, observers_added_callback) {
   var expectedChanges1 = {
@@ skipping 33 matching lines @@
     } else if (changes.database === connection2) {
       connection2Observes = connection2Observes + 1;
       if (connection2Observes > 1) {
         t.done();
       }
     } else {
       assert_unreached("unknown changes");
     }
   };
 
-  var obs = new IDBObserver(
-      t.step_func(observeFunction),
-      { operationTypes: ['clear', 'put', 'add', 'delete'] });
+  var obs = new IDBObserver(t.step_func(observeFunction));
 
   var cb1 = observers_added_barrier(t);
   var cb2 = observers_added_barrier(t);
   openDB(t, db1_name, t.step_func(function(db) {
     connection1 = db;
     var txn1 = db.transaction(['store1'], 'readonly');
     var txn2 = db.transaction(['store2'], 'readonly');
     // Start observing!
-    obs.observe(db, txn1);
-    obs.observe(db, txn2);
+    obs.observe(db, txn1, {operationTypes: ['clear', 'put', 'add', 'delete']});
+    obs.observe(db, txn2, {operationTypes: ['clear', 'put', 'add', 'delete']});
 
     txn1.oncomplete = cb1;
     txn2.oncomplete = cb2;
     txn1.onerror = t.unreached_func('transaction should not fail');
     txn2.onerror = t.unreached_func('transaction should not fail');
   }));
   var cb3 = observers_added_barrier(t);
   openDB(t, db2_name, t.step_func(function(db) {
     connection2 = db;
     var txn = db.transaction(['store3'], 'readonly');
-    obs.observe(db, txn);
+    obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
     txn.oncomplete = cb3;
     txn.onerror = t.unreached_func('transaction should not fail');
   }));
 }, 'IDB Observers: Unobserve connection removes observers');
 
 indexeddb_observers_test(function(t, db1_name, db2_name, observers_added_callback) {
   var expectedChanges1 = {
     dbName: db1_name,
     records: {
       'store1': [{type: 'delete', key: {lower: 'a', upper: 'b'}},
@@ skipping 30 matching lines @@
     } else if (changes.database === connection2) {
       connection2Observes = connection2Observes + 1;
       if (connection2Observes > 1) {
         t.done();
       }
     } else {
       assert_unreached("unknown changes");
     }
   };
 
-  var obs = new IDBObserver(
-      t.step_func(observeFunction),
-      { operationTypes: ['clear', 'put', 'add', 'delete'] });
+  var obs = new IDBObserver(t.step_func(observeFunction));
 
   var cb1 = observers_added_barrier(t);
   var cb2 = observers_added_barrier(t);
   openDB(t, db1_name, t.step_func(function(db) {
     connection1 = db;
     var txn1 = db.transaction(['store1'], 'readonly');
     var txn2 = db.transaction(['store2'], 'readonly');
     // Start observing!
-    obs.observe(db, txn1);
-    obs.observe(db, txn2);
+    obs.observe(db, txn1, {operationTypes: ['clear', 'put', 'add', 'delete']});
+    obs.observe(db, txn2, {operationTypes: ['clear', 'put', 'add', 'delete']});
 
     txn1.oncomplete = cb1;
     txn2.oncomplete = cb2;
     txn1.onerror = t.unreached_func('transaction should not fail');
     txn2.onerror = t.unreached_func('transaction should not fail');
   }));
   var cb3 = observers_added_barrier(t);
   openDB(t, db2_name, t.step_func(function(db) {
     connection2 = db;
     var txn = db.transaction(['store3'], 'readonly');
-    obs.observe(db, txn);
+    obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
     txn.oncomplete = cb3;
     txn.onerror = t.unreached_func('transaction should not fail');
   }));
 }, 'IDB Observers: Close connection removes observers');
 
 done();