docs: function(process) {
  
        function processField(referencingObject,
                              referencingObjectFieldName,
                              referencingObjectFieldValue,
                              containingSnapshot) {
          if (!referencingObjectFieldValue)
            return;
  
          if (referencingObjectFieldValue instanceof
              tr.model.ObjectSnapshot)
            return null;
          if (referencingObjectFieldValue.id === undefined)
            return;
  
          var implicitSnapshot = referencingObjectFieldValue;
  
          var rawId = implicitSnapshot.id;
          var m = /(.+)\/(.+)/.exec(rawId);
          if (!m)
            throw new Error('Implicit snapshots must have names.');
          delete implicitSnapshot.id;
          var name = m[1];
          var id = m[2];
          var res;
  
          var cat;
          if (implicitSnapshot.cat !== undefined)
            cat = implicitSnapshot.cat;
          else
            cat = containingSnapshot.objectInstance.category;
  
          var baseTypename;
          if (implicitSnapshot.base_type)
            baseTypename = implicitSnapshot.base_type;
          else
            baseTypename = undefined;
  
          try {
            res = process.objects.addSnapshot(
                id, cat,
                name, containingSnapshot.ts,
                implicitSnapshot, baseTypename);
          } catch (e) {
            this.model_.importWarning({
              type: 'object_snapshot_parse_error',
              message: 'While processing implicit snapshot of ' +
                  rawId + ' at ts=' + containingSnapshot.ts + ': ' + e
            });
            return;
          }
          res.objectInstance.hasImplicitSnapshots = true;
          res.containingSnapshot = containingSnapshot;
          res.snapshottedOnThread = containingSnapshot.snapshottedOnThread;
          referencingObject[referencingObjectFieldName] = res;
          if (!(res instanceof tr.model.ObjectSnapshot))
            throw new Error('Created object must be instanceof snapshot');
          return res.args;
        }
  
        /**
         * Iterates over the fields in the object, calling func for every
         * field/value found.
         *
         * @return {object} If the function does not want the field's value to be
         * iterated, return null. If iteration of the field value is desired, then
         * return either undefined (if the field value did not change) or the new
         * field value if it was changed.
         */
        function iterObject(object, func, containingSnapshot, thisArg) {
          if (!(object instanceof Object))
            return;
  
          if (object instanceof Array) {
            for (var i = 0; i < object.length; i++) {
              var res = func.call(thisArg, object, i, object[i],
                                  containingSnapshot);
              if (res === null)
                continue;
              if (res)
                iterObject(res, func, containingSnapshot, thisArg);
              else
                iterObject(object[i], func, containingSnapshot, thisArg);
            }
            return;
          }
  
          for (var key in object) {
            var res = func.call(thisArg, object, key, object[key],
                                containingSnapshot);
            if (res === null)
              continue;
            if (res)
              iterObject(res, func, containingSnapshot, thisArg);
            else
              iterObject(object[key], func, containingSnapshot, thisArg);
          }
        }
  
        // TODO(nduca): We may need to iterate the instances in sorted order by
        // creationTs.
        process.objects.iterObjectInstances(function(instance) {
          instance.snapshots.forEach(function(snapshot) {
            if (snapshot.args.id !== undefined)
              throw new Error('args cannot have an id field inside it');
            iterObject(snapshot.args, processField, snapshot, this);
          }, this);
        }, this);
      }