Pref service: support for incognito prefs

services/preferences/public/interfaces/preferences.mojom

 // Copyright 2016 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.
 
 module prefs.mojom;
 
+import "mojo/common/file_path.mojom";
+import "mojo/common/string16.mojom";
 import "mojo/common/values.mojom";
-import "services/preferences/public/interfaces/preferences_configuration.mojom";
+import "services/preferences/public/interfaces/tracked_preference_validation_delegate.mojom";
 
 const string kServiceName = "preferences";
 const string kForwarderServiceName = "preferences_forwarder";
 
 // The know pref store types.
 //
 // Should be kept in sync with PrefValueStore::PrefStoreType.
 enum PrefStoreType {
   MANAGED,
   SUPERVISED_USER,
   EXTENSION,
   COMMAND_LINE,
+  INCOGNITO,

[Sam McNally, 2017/05/10 01:22:16]

Below USER.

[Bernhard Bauer, 2017/05/11 14:34:33]

I thought the idea was that this would be the store where pref writes end up,
and the user store below it is only to get copy-on-write semantics?

Another way might be to just get rid of the whitelisting in the existing
OverlayPrefStore (so it would essentially do the copy-on-write for all prefs)?

(Also, I'm sorry this is taking so long, but while I'm somewhat familiar with
the technical workings, I really don't own the feature anymore, so I'm hesistant
to just give a go-ahead here.)

[tibell, 2017/05/11 22:44:42]

I should probably name this enum value better (UNDERLYING_USER perhaps, with a
comment explaining what that means). The intention was for this enum value to be
for the read-only view of the underlying profile's USER store and have the USER
store for the incognito profile be an in-memory read-write store.

Note that the current OverlayPrefStore is not a whitelist of prefs that may be
written to the underlying profile but a blacklist of prefs which are only stored
in-memory. This is one reason I want to get rid of the current thing. It makes
it very easy to write to the underlying profile by misstake.

[Bernhard Bauer, 2017/05/12 09:44:30]

Right, what I meant was: assuming that the change in behavior is desired, could
we just change the default behavior to what you describe? 

   USER,
   RECOMMENDED,
   DEFAULT,
 };
 
 // Allows observing changes to prefs stored in a |PrefStore|.
 interface PrefStoreObserver {
   // Preferences have been changed.
   OnPrefsChanged(array<PrefUpdate> updates);
 
@@ skipping 59 matching lines @@
   // Connect to all registered pref stores, retrieving the current values of all
   // prefs in each store and an |observer| interfaces through which updates can
   // be received. The client asserts that it is already connected to the
   // |already_connected_types| pref stores through some other means, so the
   // Connect call will not connect to those.
   [Sync]
   Connect(PrefRegistry pref_registry,
           array<PrefStoreType> already_connected_types) =>
       (PersistentPrefStoreConnection connection,
        map<PrefStoreType, PrefStoreConnection> connections);
+
+  // Connect to a read-only view of the user pref store. Used for incognito.
+  ConnectToUserPrefStore(PrefStore& request);
 };
 
 // An update to a subcomponent of a pref.
 struct SubPrefUpdate {
   // The path to the changed value within the pref.
   array<string> path;
   // The new value; a null |value| indicates a delete.
   mojo.common.mojom.Value? value;
 };
 
@@ skipping 38 matching lines @@
   // PrefRegistry::PrefRegistrationFlags and
   // PrefRegistrySyncable::PrefRegistrationFlags.
   uint32 flags;
 };
 
 interface PrefServiceControl {
   // Initializes the pref service. This must be called before the service can
   // be used.
   Init(PersistentPrefStoreConfiguration configuration);
 };
+
+// ---------------------------------------------------------------------
+// Service Configuration
+
+union PersistentPrefStoreConfiguration {
+  SimplePersistentPrefStoreConfiguration simple_configuration;
+  TrackedPersistentPrefStoreConfiguration tracked_configuration;
+  IncognitoPersistentPrefStoreConfiguration incognito_configuration;
+};
+
+struct SimplePersistentPrefStoreConfiguration {
+  mojo.common.mojom.FilePath pref_filename;
+};
+
+// These parameters are passed to prefs::CreateTrackedPersistentPrefStore() in
+// services/preferences/persistent_pref_store_factory.cc.
+struct TrackedPersistentPrefStoreConfiguration {
+  mojo.common.mojom.FilePath unprotected_pref_filename;
+  mojo.common.mojom.FilePath protected_pref_filename;
+  array<TrackedPreferenceMetadata> tracking_configuration;
+  uint64 reporting_ids_count;
+  string seed;
+  string legacy_device_id;
+  string registry_seed;
+  mojo.common.mojom.String16 registry_path;
+  TrackedPreferenceValidationDelegate? validation_delegate;
+  ResetOnLoadObserver? reset_on_load_observer;
+};
+
+struct TrackedPreferenceMetadata {
+  enum EnforcementLevel { NO_ENFORCEMENT, ENFORCE_ON_LOAD };
+
+  enum PrefTrackingStrategy {
+    // Atomic preferences are tracked as a whole.
+    ATOMIC,
+    // Split preferences are dictionaries for which each top-level entry is
+    // tracked independently. Note: preferences using this strategy must be kept
+    // in sync with TrackedSplitPreferences in histograms.xml.
+    SPLIT,
+  };
+
+  enum ValueType {
+    IMPERSONAL,
+    // The preference value may contain personal information.
+    PERSONAL,
+  };
+
+  uint64 reporting_id;
+  string name;
+  EnforcementLevel enforcement_level;
+  PrefTrackingStrategy strategy;
+  ValueType value_type;
+};
+
+interface ResetOnLoadObserver {
+  OnResetOnLoad();
+};
+
+struct IncognitoPersistentPrefStoreConfiguration {
+  // A connector for the underlying user's prefs. Used to serve that user's
+  // prefs in a read-only fashion.
+  PrefStoreConnector connector;
+};