Get desktop application:
View/edit binary Protocol Buffers messages
Properties of app list objects.
Used in:
Unique identifier for the item: * TYPE_FOLDER: Folder id (generated) * TYPE_APP: App Id
Item name (FOLDER).
Id of the parent (folder) item.
Marked OBSOLETE because this is unused for the app list. Which page this item will appear on in the app list.
Where on a page this item will appear.
Where on a shelf this item will appear. Note that not all apps are pinned to the shelf by the user -- some might originate from the PinnedLauncherApps policy. See `is_user_pinned` for more details.
Whether the app was pinned to shelf by the user or not (apps can also be pinned by other means such as enterprise policies). The eventual consistency (a sufficient amount of time after the rollout) promise here is for this field to be synced with the pin ordinal: `item_pin_ordinal.IsValid() <=> is_user_pinned.has_value()`. However, it's okay for this contract to be violated in the meantine. * missing value indicates that either `item_pin_ordinal` is invalid or this field is new and hasn't yet been processed by sync. * `true` means that the app was pinned by the user. This definition is used in a relaxed way -- for instance, default OS apps that are shown in the shelf (like Chrome itself) also have this value set to true. * `false` means that the app was pinned by PinnedLauncherApps policy. Note that user pin has priority: if an app was first pinned by the user and then additionally specified in PinnedLauncherApps, this value will be set to true.
Identifier for the app package of the item. Package Ids are stable and globally unique across app platforms, whereas App Id stored in item_id is not.
What type of item this is.
Used in:
An app, whether a web app, Android app, etc. For bookmark apps (URL shortcuts), additional information such as their URLs are kept in the AppSpecifics.bookmark_app_foobar fields.
A request to remove any matching default installed apps.
A folder containing entries whose |parent_id| matches |item_id|.
Obsolete type, intended for URL shortcuts, that was never implemented.
A "page break" item (Indicate creation of a new page in app list).
The color groups used for grouping together icons by colors.
Used in:
Used in:
The item icon's background color.
The item icon's hue.
Settings related to push notifications for apps.
Used in:
DEPRECATED: Use oauth_client_id below. Whether or not the user has setup notifications at least once. The value for this field will start out false and will be set to true when the user accepts receiving notifications for the first time and then it will always remain true.
Whether or not the user has disabled notifications.
OAuth2 client id to which the user granted the notification permission. This field will start out empty. It will be set when the user accepts receiving notifications. This field is used when the user revokes the notifications permission. Note that it is never cleared after it was set once. Hence, the presence of this field can be used to determine if the user has setup notifications at least once for the given app.
Properties of app setting sync objects; just an extension setting.
Used in:
Properties of app sync objects. For now, an app is just an extension. We keep the two data types separate for future-proofing purposes.
Used in:
Extension data.
Notification settings.
This controls where on a page this application icon will appear.
This specifics which page the application icon will appear on in the NTP. This values only provide the order within the application pages, not within all of the panels in the NTP.
This describes how the extension should be launched.
DEPRECATED. See https://crbug.com/1233303.
DEPRECATED. See https://crbug.com/1233303.
DEPRECATED. See https://crbug.com/1233303.
This is information about linked icons (that is, icons that are downloaded from outside the app's bundle of files.
DEPRECATED. See https://crbug.com/1233303.
DEPRECATED. See https://crbug.com/1233303.
The possible launch types for an app. This enum should be kept in sync with extensions::LaunchType.
Used in:
Properties of arc package objects.
Used in:
Unique identifier for the item: Android package name.
Android package version.
Last Android id generated when Android side backups data.
Last time internal value that Android side backups data.
Whether this client should cull (delete) expired autofill entries when autofill sync is enabled.
Used in:
Next tag: 11
Used in:
The id for this offer data. Will be used as the client tag.
The link leading to the offer details page on Gpay app. Will be populated on Android only.
Merchant domain and merchant app package name refers to the merchant this offer is applied to.
The expiry of this offer. Will be represented in the form of unix epoch time in seconds. Once the offer is expired it will not be shown in the client.
The unique offer data for different offer types.
The reward type of the offer. Will be used to generate the display text in the UI. Each type has its own client side text template.
Proto containing data specific to a card-linked offer.
Used in:
The server id of the card to which the offer is linked.
Strings to be shown in client UI, based on the offer type and details.
Used in:
A message translated in the user's GPay app locale, explaining the value of the offer. For example, a promo code offer might display "$5 off on shoes, up to $50."
A message translated in the user's GPay app locale and shown on mobile as a link, prompting the user to click it to learn more about the offer. Generally, "See details".
A message translated in the user's GPay app locale and shown on desktop (not as a link), informing the user that exclusions and restrictions may apply to the value prop text. Generally, "Terms apply."
A message translated in the user's GPay app locale and shown on mobile, instructing them on how to redeem the offer. For example, a promo code offer might display "Tap the promo code field at checkout to autofill it."
A message translated in the user's GPay app locale and shown on desktop, instructing them on how to redeem the offer. For example, a promo code offer might display "Click the promo code field at checkout to autofill it."
This value will be shown in the offer text template as "XXX$ off".
Used in:
The string contains a number and a currency sign.
This value will be shown in the offer text template as "XXX% cashback". Percentage has a range of (0, 100].
Used in:
The string contains a number and a percent sign.
Proto containing data specific to a promo code offer.
Used in:
The actual promo code which can be applied at checkout.
An AutofillProfile.
Used in:
,Starting from M115, Autofill ignores the origin and doesn't distinguish between verified (meaning `deprecated_origin == kSettingsOrigin`) and unverified profiles anymore. However, clients prior to this milestone only accept updates to verified profiles through Sync if the remote profile is verified as well. For this reason, M115 clients and above always set the origin to kSettingsOrigin. TODO(crbug.com/1441905): Remove in a few milestones.
The time_t value of the last time this profile was used. This value makes sense wrt base::Time::To/FromTimeT, which measures from the Windows epoch.
A user chosen profile label that is used to identify the profile. The value of the label can be freely chosen by the user. Two possible label values are '$HOME$' or '$WORK$' which have a special meaning.
Contact info name fields.
Sometimes the last name is composed of two names as it is common for Hispanic/Latinx names. In the unstructured representation of the last name, there may be even a conjunction between the first and the second last name. For example, the more-complete version of Pablo Picasso's surname is "Ruiz y Picasso" containing a first last name, a conjunction (the y) and a second last name.
Contact info additional fields.
Address field. The address_home_line1/2 fields are deprecated and address_home_street_address should be used instead by joining address_home_line1/2 with a newline ("\n"). Full deprecation can not be achieved before all sync profiles have been updated with a M86+ client. TODO(crbug/1111740): Remove usages of address_home_line1/2 and mark field as deprecated.
Additional address fields for i18n.
All the information related to the apartment. Normally a combination of the apartment type (address_home_apt_type) and number (address_home_apt_num). E.g. "Apt 5".
The raw number (or identifier) of an apartment (e.g. "5") but without a prefix. The value "apt 5" would correspond to the address_home_apt.
Information describing the type of apartment (e.g. Apt, Apartamento, Sala, Departamento).
The type indicates that the address is at the intersection between two streets. This is a common way of writing addresses in Mexico.
The meaning of the field is similar to address_home_between_streets. The type should be used for "Entre calle 1" in MX addresses which also contain the "Entre calle 2" field.
The meaning of the field is similar to address_home_between_streets. The type should be used for "Entre calle 2" in MX addresses which also contain the "Entre calle 1" field.
Combination of types address_home_between_streets or address_home_landmark. Note that some address forms require the combination of both in a single field as opposed to each one separately.
Combination of types address_home_overflow and address_home_landmark. Note that some address forms require the combination of both in a single field as opposed to each one separately.
Combination of types address_home_street_location and address_home_dependent_locality. Note that some address forms require the combination of both in a single field as opposed to each one separately.
Validation status records for address fields.
Phone.
Deprecated.
The following validity-related fields have only been used in combination with an experimental features that are disabled for all clients and have been removed in M100.
Represents the validation status of value stored in the AutofillProfile.
Used in:
No verification status assigned.
The value token was parsed from a parent token. For example, the first name was derived by splitting a full name into its components.
Value was built from its subcomponents. For example, the full name was built from the first, middle and last name.
The value was observed in a form transmission. For example, the user filled a form that contained at NAME_FULL field. The value of NAME_FULL will be stored as OBSERVED.
The user used the autofill settings to verify and store this token. This is currently only applicable to the full name, since users cannot edit individual components of their name.
The token was parsed remotely.
Used in:
If any of these 3 fields are present, then all 3 should be, and it implies that this entity represents a classic autofill object. In this case, none of the autofill++ objects below should be present.
An autofill++ profile object. If present, indicates this entity represents an AutofillProfile exclusively, and no other fields (such as name/value or credit_card) should be present.
Autofill wallet data which stores the relevant card credential data.
Used in:
A server-generated unique ID for the instrument/card.
A 3 or 4 digit card verification code.
The timestamp of the last update. Used to determine data freshness.
Used in:
This field exists if and only if the "type" field equals to MASKED_CREDIT_CARD.
Unused by the client since M121. This field exists if and only if the `type` equals POSTAL_ADDRESS. TODO(crbug.com/1457187): Some server-side code still relies on this field. To keep the protos in sync, it is kept until that code is cleaned up.
This field exists if and only if the "type" field equals to CUSTOMER_DATA.
This field exists if and only if the "type" field equals to CREDIT_CARD_CLOUD_TOKEN_DATA.
This field exists if and only if the "type" field equals to PAYMENT_INSTRUMENT.
This field exists if and only if the `type` field equals to MASKED_IBAN.
Used in:
POSTAL_ADDRESS is unused by the client since M121.
Used in:
A unique ID identifying this item. Used as the client tag.
The type of usage data this entity is associated with.
Used in:
The instrument id of the actual card that the virtual card is related to.
The last four of the virtual card number. This is tied to the usage data because the virtual card number may vary depending on merchants.
The url of the merchant where the virtual card is used.
The merchant the usage data is related to on the Android platform.
Details of a bank account required to show it in the payment instrument selector.
Used in:
The name of the bank where the user has an account.
The last four digits of the account number to help the user identify their account.
The type of bank account.
Used in:
Corresponds to a single bookmark id/metadata pair.
Used in:
Bookmark local id.
Bookmarks sync metadata.
Sync proto to carry the sync metadata for the bookmarks model. It is used for persisting and loading sync metadata from disk.
Bookmark global metadata.
A set of all bookmarks metadata.
Indicates whether the reupload of bookmarks has been triggered such that they include fields like |type|, |unique_position| and |parent_guid|, which means that their sequence number has been increased (independently of whether the commit has succeeded or even started). TODO(crbug.com/1232951): remove this code when most of bookmarks are reuploaded.
Number of remote updates that were ignored because the parent folder could not be determined since sync (bookmark sync) started (since initial sync, including initial sync itself). Note that this excludes updates representing changes (moves) to existing/tracked bookmarks (i.e. the parent folder used to be known, but the new one specified in the update isn't). Only a minority of users should have a non-zero value, due to a) corrupt data, reasons unknown; or b) permanent folders that were unsupported at the time the update was received (either for the permanent folder itself or for descendants). The absence of this field should be interpreted as 'unknown', which roughly means the counter wasn't supported by the browser -M77 or below- at the time sync was enabled (it also means, it will remain 'unknown' until initial sync is exercised, e.g. sync disabled and reenabled).
See field above. Among such ignored updates, this field tracks which was the highest server version. This may be useful -in the future- to get a sense of "time" (or, since versions are opaque to the client, at least a notion of ordering with respect to other updates). The absence of this field should be interpreted as 'unknown' and does not distinguish the case between a) no updates ignored; and b) field wasn't supported at the time the last update was ignored. To distinguish between these two, the field above can be used.
Indicates whether the count of remote updates during the latest initial merge exceeded the bookmark limit. This field is mutually exclusive to all the other fields and is managed completely by the processor.
Properties of bookmark sync objects.
Used in:
URL of the bookmarked page (unset for folders).
PNG-encoded content of the favicon image (in practice 16x16, as determined by |kFaviconSize|). Empty if the bookmark has no favicon (which includes bookmark folders).
Contains legacy title which is truncated and may contain escaped symbols.
Corresponds to BookmarkNode::date_added() represented as microseconds since the Windows epoch.
The URL of the favicon image encoded in field |favicon|. Note that there are various cases where this URL may be missing (field unset or empty) even if the |favicon| field (image content) is populated: 1. WebUI pages such as "chrome://bookmarks/" are missing a favicon URL but they have a favicon. 2. Data generated by ancient clients (prior to M25) may not contain the favicon URL. 3. If the favicon URL is too large (determined by |kMaxFaviconUrlSize|) it may be omitted by clients to avoid running into the max-entity-size limit. Most notably, this includes URLs prefixed with the data: scheme that may encode the image content itself in the URL.
Introduced in M81, it represents a globally unique and immutable ID. If present, it must be the same as originator_client_item_id in lowercase, unless originator client item ID is not a valid GUID. In such cases (which is the case for bookmarks created before 2015), this GUID must match the value inferred from the combination of originator cache GUID and originator client item ID, see InferGuidForLegacyBookmark(). If not present, the value can be safely inferred using the very same methods listed above.
Contains full title as is. |legacy_canonicalized_title| is a prefix of |full_title| with escaped symbols.
Introduced in M94, represents the GUID (field |guid|) of the parent.
Introduced in M94, determines ordering among siblings. This field is redundant to the similar field in SyncEntity. If this field in specifics is set, it takes precedence over the one in SyncEntity.
Introduced in M106, corresponds to BookmarkNode::date_last_used() represented as microseconds since the Windows epoch.
Introduced in M94, determines whether this entity represents a bookmark folder. This field is redundant to the similar field in SyncEntity. If this field in specifics is set, it takes precedence over the one in SyncEntity.
Used in:
|UNSPECIFIED| is relevant only for the case where the field is not set. M94 and above should not use this value.
Used in:
Next id: 8
Used in:
The unique identifier of the benefit. Generated originally in Chrome Sync server.
The benefit description (Engligh only currently) to be shown in the UI.
When the benefit should be displayed, in UTC time.
Proto data representing the actual data of the credit card benefit, depending on the benefit type.
Proto containing data specific to a category benefit.
Used in:
The type of category purchases the benefit is eligible on.
For category benefits, represents the category of purchases that the benefit can be applied to.
Used in:
Proto containing data specific to a flat rate benefit. Empty as flat rate benefits don't have unique fields. The actual benefit (e.g. "2% cash back") is already included in the `benefit_description`.
Used in:
(message has no fields)
Proto containing data specific to a merchant benefit.
Used in:
The merchant domain that the benefit is eligible on. Example: https://www.acme.com
Used in:
Uniquely identifies the issuer of the card. This field is required when Issuer is EXTERNAL_ISSUER. Example: capitalone, amex.
Used in:
Card where the issuer is Google.
Card where the issuer is external.
The client must preserve, store, and resend the chip bag with every request. The server depends on the chip bag in order to precisely choreograph a client-server state machines. Because the client stores and sends this data on every request, the contents of the chip bag should be kept relatively small. If the server does not return a chip bag, the client must assume that there has been no change to the chip bag. The client must resend the bag of chips it had prior on the next request. The client must make the chip bag durable if and only if it processes the response from the server.
Used in:
,Server chips are deliberately oqaque, allowing the server to encapsulate its state machine logic.
Used in:
Version number as per https://www.chromium.org/developers/version-numbers.
This message contains diagnostic information used to correlate commit-related traffic with extensions-related mutations to the data models in chromium. It plays no functional role in processing this CommitMessage.
Used in:
The human-readable ID identifying the extension responsible for the traffic reported in this ChromiumExtensionsActivity.
How many times the extension successfully invoked a write operation through the bookmarks API since the last CommitMessage.
Message from a client asking the server to clear its data. This causes the server to generate a new store birthday, which allows dealing reliably with in-flight requests (in particular commits) from other clients.
No arguments needed as the store birthday and user identifier are part of an enclosing message.
Used in:
(message has no fields)
Response to a ClearServerData request.
No result fields necessary. Success/failure is indicated in ClientToServerResponse.
Used in:
(message has no fields)
Used in:
Time to wait before sending any requests to the server.
in seconds
This has been deprecated since M75.
Number of seconds to delay before the throttled client should retry.
This has been deprecated since M109.
Time to wait before issuing a retry GU.
A dictionary of custom nudge delays.
Configuration for commit quota of extension-related data types. The maximum count of tokens (=initial at browser startup) and the interval for refilling one more token if not at maximum.
Extended nudge delay for data types with depleted quota.
Client specific configuration information.
Used in:
The set of data types this client has enabled. Note that this does not include proxy types, as they do not have protocol field numbers and are placeholder types that implicitly enable protocol types.
Whether the PROXY_TABS proxy datatype is enabled on this client. Deprecated and not populated anymore since M120.
Whether the account(s) present in the content area's cookie jar match the chrome account. If multiple accounts are present in the cookie jar, a mismatch implies all of them are different from the chrome account.
Indicates that the client is not aware of any other active clients interested in the committed data types. This flag shows that it is not necessary to send invalidations for the committed data. A client is considered active if it's DeviceInfo has updated recent enough. This flag does not take into account whether standalone invalidations are enabled (as opposed to |single_client_with_standalone_invalidations|). However, it's set depending on interested data types of other devices, e.g. if there are other devices but they are not interested in SESSION data type, and current commit request contains only SESSION, it will be set to true. Introduced in M88.
A list of FCM registration tokens which are obtained from other clients. This list is used by the server to send invalidations to all other clients. If the list is empty, the server should treat this as "there is no information about other clients". In practice, this happens by the next causes: 1. This is the old client which doesn't set this field. 2. There are too many active devices and the list would have too many items. 3. An empty list could also mean that the current client is the only client. This case should be covered by the |single_client_with_standalone_invalidations| field instead (otherwise it could be mixed up with older clients). The server doesn't have to use this field and can ignore it. Note that this list does not take into account interested data types from the other clients. Introduced in M89.
Similar to |single_client| but takes into account only clients with enabled sync standalone invalidations. When set to true, there are no other clients with sync standalone invalidations interested in the committing types and hence it's not necessary to send out standalone invalidations (it may still be necessary to send out invalidations using the legacy system, see |single_client| instead). Introduced in M105.
Similar to |devices_fcm_registration_tokens| but takes into account clients which are subscribed to the data types which are committed in current commit request. A list of FCM registration tokens which are obtained from other clients. This list is used by the server to send invalidations to all other clients. If the list is empty, the server should treat this as "there is no information about other clients". In practice, this happens by the next causes: 1. This is the old client which doesn't set this field. 2. There are too many active devices and the list would have too many items. 3. An empty list could also mean that the current client is the only client. This case should be covered by the |single_client_with_standalone_invalidations| field instead (otherwise it could be mixed up with older clients). The server doesn't have to use this field and can ignore it. Introduced in M105.
Similar to |single_client| but takes into account only clients which are subscribed to old invalidations (i.e. not subscribed to sync standalone invalidations). When set to true, there are no other clients subscribed to old invalidations. Note that opposed to |single_client|, this flag does not always take into account the list of interested data types (because interested data types were introduced in M89). When the list is empty, a client is considered to be subscribed to all data types. Note that "single client" is a bit misleading since this will also be true if there are no clients with old invalidations at all. Introduced in M110.
Information about the syncer's state.
Used in:
Flag to indicate if the client has detected hierarchy conflcits. The flag is left unset if update application has not been attempted yet. The server should attempt to resolve any hierarchy conflicts when this flag is set. The client may not assume that any particular action will be taken. There is no guarantee the problem will be addressed in a reasonable amount of time. TODO(crbug.com/1315573): Deprecated in M103.
Whether the client has full sync (or, sync the feature) enabled or not.
|share| field is only used on the server for logging and can sometimes contain empty string. It is still useful for logging username when it can't be derived from access token in case of auth error.
Each ClientToServerMessage contains one request defined by the message_contents. Each type has a corresponding message field that will be present iff the message is of that type. E.g. a commit message will have a message_contents of COMMIT and its commit field will be present.
Opaque server-provided ID representing an "epoch" of the server-side data. Clients must hand this opaque ID back to the server as part of all requests within the same sync session (i.e. for all requests to the server except the very first GetUpdates request). See analogous field ClientToServerResponse.store_birthday for more details about its lifetime.
Client side state information for debugging purpose. This is only sent on the first getupdates of every sync cycle, as an optimization to save bandwidth.
Per-client state for use by the server. Sent with every message sent to the server.
Google API key.
Client's self-reported state. The client should set this on every message sent to the server, though its member fields may often be unset.
The ID that our invalidation client used to identify itself to the server. Sending the ID here allows the server to not send notifications of our own changes to our invalidator. The field was deprecated in M117 and is no longer populated.
Identifies this ClientToServerMessage as a clear server data request. This field is present when message_contents is CLEAR_SERVER_DATA.
Used in:
Up until protocol_version 24, the default was SUCCESS which made it impossible to add new enum values since older clients would parse any out-of-range value as SUCCESS. Starting with 25, unless explicitly set, the error_code will be UNKNOWN so that clients know when they're out-of-date. Note also that when using protocol_version < 25, TRANSIENT_ERROR is not supported. Instead, the server sends back a HTTP 400 error code. This is deprecated now.
Opaque server-provided ID representing an "epoch" of the server-side data, referred to as "birthday" or "store birthday". This ID remains fixed until server-side data gets cleared/reset (e.g. via ClearServerDataMessage), which clients experience as NOT_MY_BIRTHDAY error, and involves clearing all local sync metadata including the cached store birthday. This mechanism allows the server to implement clear-data/reset functionality that reliably identifies and deletes sync entities uploaded before the clear-data/reset event (e.g. via ClearServerDataMessage). Furthermore, it allows the server to deal reliably with in-flight changes from other clients upon clear-data event, because all writes issued with an outdated birthday (which in-flight writes would use) can be detected by the server.
The data types whose storage has been migrated. Present when the value of error_code is MIGRATION_DONE.
The new per-client state for this client. If set, should be persisted and sent with any subsequent ClientToServerMessages.
Present if this ClientToServerResponse is in response to a ClearServerData request.
Used in:
Currently meaningful if |error_type| is throttled or partial_failure. In the throttled case, if this field is absent then the whole client (all datatypes) is throttled. In the partial_failure case, this field denotes partial failures. The client should retry those datatypes with exponential backoff.
TODO(crbug.com/1020740): Deprecated, remove this once dependent change is done. Use WalletCreditCardCloudTokenData instead.
Used in:
Last 4-5 digits of the Cloud Primary Account Number (CPAN).
CPAN Month number 1-12.
CPAN Four-digit year (e.g. 2017).
URL of the card art to be displayed for CPAN.
Opaque identifier for the cloud token associated with the payment instrument.
Special sync datatype to notify client about People Group changes.
Used in:
Unique identifier for a collaboration group, also known as `group_id` or `group_name`.
Indicates staleness of the collaboration group, used to determine whether client should refresh cached group. Server-side derived from group `consistency_token`.
Used in:
A GUID that identifies the committing sync client. This value will be returned as originator_cache_guid for any new items.
The configuration of this client at commit time. Used by the server to make commit-time decisions about how to process datatypes that might involve server-side interaction, and e.g require explicit user intent for syncing a particular data type regardless of whether a commit for that datatype is currently being sent up.
Set of optional per-client datatype contexts.
This field need to be 256 bytes if set. This attempts to mitigate CRIME attacks when sync communicate from client to server with compression. So if compression is used, this need to set a 256 random ASCII bytes. If no compression, this field should not be set. The server can ignore the padding.
Used in:
Used in:
Sync servers may also return a new ID for an existing item, indicating a new entry's been created to hold the data the client's sending up.
The item's current version.
Last modification time (in milliseconds since Unix epoch). Allows the server to override the client-supplied mtime during a commit operation. TODO(crbug.com/1182252): Delete this field too.
Datatype specific error (if any).
Used in:
Used in:
You're out of date; update and check your data
TODO(ncarter): What's the difference between RETRY and TRANSIENT_ERROR?
Someone has a conflicting, non-expired session open
What the client sent was invalid, and trying again
won't help.
This operation would put you, or you are, over quota
Something went wrong; try again in a bit
A Compare sync entity, containing sufficient data to enable all data acquisition for rendering the Compare experience.
Used in:
The primary key for local storage.
Tracks when this entity was created.
Tracks when this entity was last modified.
The name of the comparison group.
The list of product URLs that constitute this comparison group.
Used in:
The URL of the item in the comparison.
Used in:
A globally unique, immutable UUID represented in lowercase.
The number of time this profile has been used.
The last time this profile was used.
The last time the profile was modified.
The BCP 47 language code used to format the address for display.
A user chosen profile label that is used to identify the profile. The value of the label can be freely chosen by the user.
Tracks the application that initially created the profile. The integer represents a value in the server-side enum `BillableService`. A value of 70073 represents Chrome (enum value BILLABLE_SERVICE_CHROME_PAYMENTS).
Tracks the application that applied the last modification to the non-metadata content of the profile. It represents a value in the same `BillableService` enum. All StringTokens, and the `profile_label` are considered non-metadata.
Contact info name fields.
Sometimes the last name is composed of two names as it is common for Hispanic/Latinx names. In the unstructured representation of the last name, there may be even a conjunction between the first and the second last name. For example, the more-complete version of Pablo Picasso's surname is "Ruiz y Picasso" containing a first last name, a conjunction (the y) and a second last name.
Contact info additional fields.
Address fields: These are user-provided values with no particular guarantees about their format.
Additional address fields for i18n. Includes all of the lines of a street address, including newlines, e.g. 123 Main Street, Apt. #42
A sorting code is similar to a postal code. However, whereas a postal code normally refers to a single geographical location, a sorting code often does not. Instead, a sorting code is assigned to an organization, which might be geographically distributed. The most prominent example of a sorting code system is CEDEX in France.
A dependent locality is a subunit of a locality, where a "locality" is roughly equivalent to a city. Examples of dependent localities include inner-city districts and suburbs.
The street name of the address, without a house number.
The house number, which may be alphanumeric.
Contains the floor, staircase or apartment number within a building.
All the information related to the apartment. Normally a combination of the apartment type (address_apt_type) and number (address_apt_num). E.g. "Apt 5".
The apartment number within a building.
Information describing the type of apartment (e.g. Apt, Apartamento, Sala, Departamento).
The floor number within a building.
Contains both the street and house number.
Indicates that the address is at the intersection between two streets. It is normally a combination of between_streets_1 and _2. This is a common way of writing addresses in Mexico.
The meaning of the field is similar to address_between_streets. The type should be used for "Entre calle 1" in MX addresses which also contain the "Entre calle 2" field.
The meaning of the field is similar to address_between_streets. The type should be used for "Entre calle 2" in MX addresses which also contain the "Entre calle 1" field.
Combination of types address_between_streets or address_landmark. Note that some address forms require the combination of both in a single field as opposed to each one separately.
Combination of types address_overflow and address_landmark. Note that some address forms require the combination of both in a single field as opposed to each one separately.
Combination of types address_street_location and address_dependent_locality. Note that some address forms require the combination of both in a single field as opposed to each one separately.
Phone.
Used in:
An `autofill::ProfileTokenQuality::ObservationType`. Represented as a uint32 to retain future enum values (since this is proto2). The `ObservationType`'s underlying type is uint8_t, but this is not supported by protos. Since the uint32 Proto type uses variable-length encoding, uint32 has a similar size as a single element byte[].
The `autofill::ProfileTokenQuality::FormSignatureHash` has type uint8_t. Like for `type`, this should have the (non-existing) data type uint8.
A token with a string interpretation of the value.
Used in:
Metadata that is attached to every token type.
Used in:
Stores a hash of the token value that this metadata is associated with. This is used by Autofill to detect changes of the token value by external integrators.
Represents the validation status of a stored value.
Used in:
No verification status assigned.
The value token was parsed from a parent token. For example, the first name was derived by splitting a full name into its components.
Value was built from its subcomponents. For example, the full name was built from the first, middle and last name.
The value was observed in a form transmission. For example, the user filled a form that contained at NAME_FULL field. The value of NAME_FULL will be stored as OBSERVED.
The user used the settings UI to verify and store this token. This is currently only applicable to the full name, since users cannot edit individual components of their name.
The token was parsed remotely.
Used in:
Asymmetric private-keys used for cross user sharing.
Used in:
,The key version, used for key rotation.
Private key on Curve25519 (32 bytes).
Used in:
, ,The key version, used for key rotation and consensus.
Public key on Curve25519 (32 bytes).
Used in:
Contains all known Nigori keys.
Default key is the key, that should be used for encryption. Can be empty in case we have pending keys (waiting for explicit passphrase, or client didn't received keystore keys).
Contains cross user sharing related keys.
Used in:
Datatype id.
Delay in milliseconds.
Used in:
Method used for deriving keys from custom passphrase.
Salt used for the derivation of the key from the custom passphrase. Should be set iff custom_passphrase_key_derivation_method == SCRYPT_8192_8_11.
A single datatype's sync context. Allows the datatype to pass along datatype specific information with its own server backend.
Used in:
, , ,The type this context is associated with.
The context for the datatype.
The version of the context.
Used in:
, ,An integer identifying the data type whose progress is tracked by this marker. The legitimate values of this field correspond to the protobuf field numbers of all EntitySpecifics fields supported by the server. These values are externally declared in per-datatype .proto files.
An opaque-to-the-client sequence of bytes that the server may interpret as an indicator of the client's knowledge state. If this is empty or omitted by the client, it indicates that the client is initiating a a first-time sync of this datatype. Otherwise, clients must supply a value previously returned by the server in an earlier GetUpdatesResponse. These values are not comparable or generable on the client. The opaque semantics of this field are to afford server implementations some flexibility in implementing progress tracking. For instance, a server implementation built on top of a distributed storage service -- or multiple heterogenous such services -- might need to supply a vector of totally ordered monotonic update timestamps, rather than a single monotonically increasing value. Other optimizations may also be possible if the server is allowed to embed arbitrary information in the progress token. Server implementations should keep the size of these tokens relatively small, on the order of tens of bytes, and they should remain small regardless of the number of items synchronized. (A possible bad server implementation would be for progress_token to contain a list of all the items ever sent to the client. Servers shouldn't do this.)
This field will be included only in GetUpdates with origin GU_TRIGGER.
The garbage collection directive for this data type. The client should purge items locally based on this directive. Since this directive is designed to be sent from server only, the client should persist it locally as needed and avoid sending it to the server.
Used in:
Each of the following fields correspond to different kinds of events. as a result, only one is set during any single DebugEventInfo. A singleton event. See enum definition.
A sync cycle completed.
A datatype triggered a nudge.
A notification triggered a nudge.
Used in:
Whether cryptographer is ready to encrypt and decrypt data.
Cryptographer has pending keys which indicates the correct passphrase has not been provided yet.
Indicates client has dropped some events to save bandwidth.
Information about a device that is running a sync-enabled Chrome browser. We are mapping the per-client cache guid to more specific information about the device.
Used in:
The cache_guid created to identify a sync client on this device.
A non-unique but human readable name to describe this client.
The platform of the device. Deprecated in M110, but still populated for backwards compatibility. Replaced by os_type + device_form_factor.
The UserAgent used when contacting the Chrome Sync server. Only present when talking to the HTTP server.
The Chrome instance's version. Updated (if necessary) on every startup. DEPRECATED in M92. Still populated for backward compatibility.
Last time when pre-sync data on the device was saved. The device can be restored to state back to this time. In millisecond since UNIX epoch. DEPRECATED in M50.
Device_id that is stable until user signs out. This device_id is used for annotating login scoped refresh token. Present only for Chrome Clients.
This field is updated to be the current time periodically, and is also set to the current time whenever another field changes. By examining the difference between this field and the current time, it should be possible to reason about the inactivity of any device that was syncing at one time.
Device info fields that are specific to a feature. This is information that can not be derived from the other fields in the proto and are not general enough to be used by another feature.
Device specific information for Sharing feature.
Model of device.
Name of device manufacturer.
The interval in minutes with which |last_updated_timestamp| is updated to the sync servers if online and while sync is actively running (e.g. excludes backgrounded apps on Android). Introduced in M81. The legacy default was 1 day.
Device specific information for Sync invalidations.
Information for contacting this device in order to perform security key operations.
Unique hardware identifier string which details the HW combination of a ChromeOS device. This field will be empty on other OS devices.
Version information to pin-point which client implementation this is.
The OS type the device.
The form factor of the device.
Properties of Dictionary objects.
Used in:
A spelling which when typed is treated as a correctly spelled word.
Used in:
(message has no fields)
Encrypted sync data consists of two parts: a key name and a blob. Key name is the name of the key that was used to encrypt blob and blob is encrypted data itself. The reason we need to keep track of the key name is that a sync user can change their passphrase (and thus their encryption key) at any time. When that happens, we make a best effort to reencrypt all nodes with the new passphrase, but since we don't have transactions on the server-side, we cannot guarantee that every node will be reencrypted. As a workaround, we keep track of all keys, assign each key a name (by using that key to encrypt a well known string) and keep track of which key was used to encrypt each node.
Used in:
, , ,base64-encoded.
Used for encrypting data in the user's account.
Used for encrypting/authenticating using Public-private cryptography primarily across user accounts, e.g. sharing invitations.
Flags for enabling the experimental enhanced bookmarks feature.
Used in:
Sync proto to store entity metadata in model type storage.
Used in:
,A hash based on the client tag and model type. Used for various map lookups. Should always be available. Sent to the server as SyncEntity::client_tag_hash.
The entity's server-assigned ID. Prior to the item's first commit, we leave this value as an empty string. The initial ID for a newly created item has to meet certain uniqueness requirements, and we handle those on the sync thread.
Whether or not the entity is deleted.
A version number used to track in-progress commits. Each local change increments this number.
The sequence number of the last item known to be successfully committed.
The server version on which this item is based. If there are no local changes, this is the version of the entity as we see it here. If there are local changes, this is the version of the entity on which those changes are based.
Entity creation and modification timestamps. Assigned by the client and synced by the server, though the server usually doesn't bother to inspect their values. They are encoded as milliseconds since the Unix epoch.
A hash of the current entity specifics value. Used to detect whether entity's specifics value has changed without having to keep specifics in memory.
A hash of the last specifics known by both the client and server. Used to detect when local commits and remote updates are just for encryption. This value will be the empty string only in the following cases: the entity is in sync with the server, has never been synced, or is deleted.
Used for positioning entities among their siblings. Relevant only for data types that support positions (e.g bookmarks). Refer to its definition in unique_position.proto for more information about its internal representation.
Used only for bookmarks. It's analogous to |specifics_hash| but it exclusively hashes the content of the favicon image, as represented in proto field BookmarkSpecifics.favicon, using base::PersistentHash().
Last specifics known by both the client and server. Used during commits to the server in order to prevent data loss caused by older clients dealing with unknown proto fields (fields that were introduced later). Datatypes (ModelTypeSyncBridge) may implement logic to trim down (or fully clear) this proto prior to caching, to avoid the memory and I/O overhead of dealing with an extra copy of the data. Introduced in M101.
If the entity is deleted, this field will record the chromium version (e.g. 117.0.5875.1) that originated the deletion. Introduced in M117.
Metadata used for shared data types. Must not be present for regular data types. Introduced in M124.
Used in:
Collaboration ID which the current entity belongs to.
Used in:
, ,If a datatype is encrypted, this field will contain the encrypted original EntitySpecifics. The extension for the datatype will continue to exist, but contain only the default values. Note that currently passwords employ their own legacy encryption scheme and do not use this field.
When adding a new type, follow the docs below and keep this comment as the last entry. https://www.chromium.org/developers/design-documents/sync/integration-checklist/
No-longer-supported data types, in various stages of removal. TODO(crbug.com/1395003): Eventually, these should all become "reserved" fields, or at least use "EmptySpecifics". But some of them are still needed by the server, e.g. to support older clients.
A message to notify the server of certain sync events. Idempotent. Send these to the /event endpoint.
(message has no fields)
This request allows an unauthenticated client to check the status of the experiments which do not require user authentication. The status of an experiment for a specific client can be determined based on the user agent string and/or the client id sent in the HTTPS POST request.
Enumerates the experiments for which the status should be returned. An experiment name must be the same as one of the field names specified in ExperimentsSpecifics. See sync/protocol/experiments_specifics.proto.
Response to an experiment status request.
Minimal time to wait before issuing another request.
The experiments that the client has asked for, with each experiment containing exactly one experiment flag. The client can inspect the embedded flag to obtain the experiment status. Note that the number of experiments should be less than or equal to the number of experiment_name sent in the request since it is possible that there is no experiment matching an experiment_name.
Contains one flag or set of related flags. Each node of the experiments type will have a unique_client_tag identifying which flags it contains. By convention, the tag name should match the sub-message name.
Used in:
,No longer used as of M43.
No longer used as of M72.
No longer used as of M51.
Properties of extension setting sync objects.
Used in:
,Id of the extension the setting is for.
Setting key.
Setting value serialized as JSON.
Properties of extension sync objects. Merge policy: the settings for the higher version number win; in the case of a tie, server wins.
Used in:
,Globally unique id for this extension.
The known installed version.
Auto-update URL to use for this extension. May be blank, in which case the default one (i.e., the one for the Chrome Extensions Gallery) is used.
Whether or not this extension is enabled.
Whether or not this extension is enabled in incognito mode.
DEPRECATED. See https://crbug.com/1233303.
Whether this extension was installed remotely, and hasn't been approved by a user in chrome yet.
DEPRECATED. See https://crbug.com/1014183.
DEPRECATED. See https://crbug.com/839681.
Bitmask of the set of reasons why the extension is disabled (see extensions::disable_reason::DisableReason). Only relevant when enabled == false. Note that old clients (<M45) won't set this, even when enabled is false.
Used in:
The image data for the favicon (PNG encoded).
The favicon dimensions.
Image data for favicons. Multiple resolutions are supported.
Used in:
The url of the favicon image.
A normal low-resolution web favicon (max resolution 16x16).
A slightly higher-resolution web favicon (max resolution 32x32).
A high-resolution touch favicon (not precomposed, max resolution 64x64).
A high-resolution touch favicon (precomposed, max resolution 64x64).
Whether the favicon sync datatypes are enabled, and what parameters they should operate under.
Used in:
Tracking info for of favicon images. These control expiration of images from sync based on recency, bookmark state, etc.
Used in:
The url of the favicon image.
The last time a page using this favicon was visited (in milliseconds since linux epoch).
Whether this favicon is currently bookmarked or not.
Feature specific information about the device that is running a sync-enabled Chrome browser. Adding to this proto is discouraged and should only be added when the information can not be derived more generally.
Used in:
Tracks whether the SendTabToSelf feature is enabled on the device. For this to be true, two things must be true: (1) The receiving side of the feature must be enabled on the device (2) The user has enabled sync for this feature
User reused their GAIA password on another website.
Used in:
,Logged when we try to detect whether the password was reused on a Phishing or a Low-reputation site.
Logged when we detect a password re-use event on a non-GAIA site. If the user hasn’t enabled SafeBrowsing, this will be the last event.
Used in:
Used in:
Is SafeBrowsing enabled?
If SafeBrowsing is enabled, is the user opted-in to extended reporting or Scout?
Used in:
Logged when the user interacts with the warning UI shown to encourage password change if the site is Phishing or Low-reputation.
Used in:
Used in:
The user took the action suggested by the warning prompt.
The user clicked ignore in the warning prompt.
The warning UI was ignored, i.e. not interacted with by the user. This could happen if the user navigates away from the page.
The user clicked "Change Password" on chrome://settings page.
Used in:
PhishGuard token that identifies the verdict on the server.
Used in:
URL did match the password reuse allowlist. No further action required related to this re-use event.
The URL exists in the client’s cache. No further action required related to this re-use event. This event also logs the ReputationVerdict.
A valid response received from the SafeBrowsing service. This event also logs the ReputationVerdict.
Unable to get a valid response from the SafeBrowsing service.
We won't be able to compute reputation for the URL e.g. local IP address, localhost, not-yet-assigned by ICANN gTLD, etc.
URL did match enterprise allowlist. No further action required related to this re-use event.
Password reuse lookup is turned off by enterprise policy. No further action required related to this re-use event.
The following two are only present for CACHE_HIT and REQUEST_SUCCESS. The verdict received from the Reputation service. This is set only if the user has SafeBrowsing enabled and we fetch the verdict from the cache or by sending a verdict request.
Used in:
Used in:
Deprecated in M124. This field is unused because it would be hard to use `active_collaboration_ids`. The client should rely on the presence of the corresponding fields instead.
This field specifies the watermark for the versions which should get garbage collected. The client should purge all sync entities when receiving any value of this. This is a change from previous behavior, where the client would only be required to purge items older than the specified watermark. TODO(crbug.com/877951): Rename this to make clear that whenever it's set, the client will delete ALL data, regardless of its value.
This field contains a list of active collaboration IDs which are available to the user. The client should stop tracking any shared sync entities with collaborations which are not in the list. Note that if the list is empty, an empty `collaboration_gc` is expected to be provided by the server. Introduced in M124.
Used in:
Used in:
Flags for enabling the GCM feature.
Used in:
Flags for enabling GCM channel for invalidations.
Used in:
This message communicates additional per-type information related to requests with origin GU_TRIGGER. This message is not relevant when any other origin value is used. Introduced in M29.
Used in:
An opaque-to-the-client string of bytes, received through a notification, that the server may interpret as a hint about the location of the latest version of the data for this type. Introduced in M29.
This flag is set if the client was forced to drop hints because the number of queued hints exceeded its limit. The oldest hints will be discarded first. Introduced in M29.
This flag is set when the client suspects that its list of invalidation hints may be incomplete. This may be the case if: - The client is syncing for the first time. - The client has just restarted and it was unable to keep track of invalidations that were received prior to the restart. - The client's connection to the invalidation server is currently or was recently broken. It's difficult to provide more details here. This is implemented by setting the flag to false whenever anything that might adversely affect notifications happens (eg. a crash, restart on a platform that doesn't support invalidation ack-tracking, transient invalidation error) and is unset only after we've experienced one successful sync cycle while notifications were enabled. This flag was introduced in M29.
This counts the number of times the syncer has been asked to commit changes for this type since the last successful sync cycle. The number of nudges may not be related to the actual number of items modified. It often correlates with the number of user actions, but that's not always the case. Introduced in M29.
This counts the number of times the syncer has been explicitly asked to fetch updates for this type since the last successful sync cycle. These explicit refresh requests should be relatively rare on most platforms, and associated with user actions. For example, at the time of this writing the most common (only?) source of refresh requests is when a user opens the new tab page on a platform that does not support sessions invalidations. Introduced in M29.
This flag is set if the invalidation server reports that it may have dropped some invalidations at some point. Introduced in M33.
This flag is set if this GetUpdate request is due at least in part due to the fact that this type has not finished initial sync yet, and the client would like to initialize itself with the server data. Only some types support performing an initial sync as part of a normal GetUpdate request. Many types must be in configure mode when fetching initial sync data. Introduced in M38.
This flag is set if this GetUpdate request is due to client receiving conflict response from server, so client needs to sync and then resolve conflict locally, and then commit again. Introduced in M42.
Used in:
,True if notifications were enabled for this GetUpdateMessage. Note: Ideally this would be moved out of GetUpdatesCallerInfo, so that GetUpdatesCallerInfo itself can be removed.
Used in:
Indicates the reason for the GetUpdatesMessage. This was *mostly* deprecated in M29. GetUpdatesOrigin is the new way to encode the reason for the GetUpdates request, but some parts of the server still rely on this field. It also still contains the "notifications_enabled" flag which needs to be moved elsewhere before this can be fully removed. See https://crbug.com/510165.
Indicates whether related folders should be fetched.
Per-datatype progress marker. With the exception of certain configuration or initial sync requests, the client should include one instance of this field for each enabled data type.
Indicates whether the response should be sent in chunks. This may be needed for devices with limited memory resources. If true, the response will include one or more ClientToServerResponses, with the first one containing GetUpdatesMetadataResponse, and the remaining ones, if any, containing GetUpdatesStreamingResponse. These ClientToServerResponses are delimited by a length prefix, which is encoded as a varint.
Whether the client needs the server to provide an encryption key for this account. Note: this should typically only be set on the first GetUpdates a client requests. Clients are expected to persist the encryption key from then on. The allowed frequency for requesting encryption keys is much lower than other datatypes, so repeated usage will likely result in throttling.
This value is an updated version of the GetUpdatesCallerInfo's GetUpdatesSource. It describes the reason for the GetUpdate request. Introduced in M29.
Whether this GU also serves as a retry GU. Any GU that happens after retry timer timeout is a retry GU effectively.
Set of optional per-client datatype contexts.
Used in:
New sync entries that the client should apply.
Approximate count of changes remaining - use this for UI feedback. If present and zero, this estimate is firm: the server has no changes after the current batch.
Opaque, per-datatype timestamp-like tokens. Clients should retain and persist the values returned in this field, and present them back to the server to indicate the starting point for future update requests. This will be sent only if the client provided |from_progress_marker| in the update request. The server may provide a new progress marker even if this is the end of the batch, or if there were no new updates on the server; and the client must save these. If the server does not provide a |new_progress_marker| value for a particular datatype, when the request provided a |from_progress_marker| value for that datatype, the client should interpret this to mean "no change from the previous state" and retain its previous progress-marker value for that datatype.
The current encryption keys associated with this account. Will be set if the GetUpdatesMessage in the request had need_encryption_key == true or the server has updated the set of encryption keys (e.g. due to a key rotation).
Set of optional datatype contexts server mutations.
Used in:
The global IDs of the navigations to delete.
Time range for searching for navigations to delete. Client should delete all navigations to a URL between [start_time_usec, end_time_usec] if one of them matches a |global_id|.
Used in:
Properties of history delete directive sync objects.
Used in:
Exactly one of the fields below must be filled in. Otherwise, this delete directive must be ignored.
Whether history delete directives are enabled.
Used in:
A history sync entity - this roughly represents one navigation, including its full redirect chain (but not referrals). Fields correspond to similarly named fields in history::VisitRow and history::URLRow.
Used in:
Timestamp, also called "global ID" in some places (e.g. in delete directives). This uniquely identifies the entity.
Cache GUID of the client that produced this entity, aka the "originator".
The redirect chain. The first entry is the URL the user originally navigated to; the last one is where they ended up. If there were no redirects, this has only one entry.
Whether the redirect chain in this entity is the continuation of a prior chain, and whether a continuation of this chain exists, in other entities. These are effectively the inverse of the CHAIN_START/CHAIN_END page transition qualifiers in Chrome. They are typically both false, since the whole chain is included in `redirect_entries`, but in some cases (notably, client redirects) a redirect chain may be split up across multiple entities.
If this is set to true, then the redirect chain was too long and some entries were trimmed from the middle, so `redirect_entries` only corresponds to some of the first plus some of the last entries of the actual redirect chain.
The PageTransition for the navigation.
The ID of the visit, on the originator client, that was a referrer for this one, or 0 if no referrer exists.
The ID of the visit, on the originator client, that opened this one, or 0 if no opener exists.
The ID of the cluster that this visit belongs to on the originator client, or 0 if the originator client does not support setting this field or the visit does not belong to any cluster.
The duration of the visit, in microseconds. Zero if the visit hasn't been finished (or the duration wasn't updated for some other reason).
The kind of browser where this visit happened.
The SessionID of the window and tab where the visit happened. Can be used to link together possibly-related visits. Note: These are only unique per-client, so always use together with `originator_cache_guid`.
The ID for the task associated with this navigation, which is globally unique with high probability.
The IDs of ancestor tasks. These can be used to construct a tree of related visits.
The HTTP response code of the navigation.
The language of the content on the page, as an ISO 639 language code (usually two letters). May be "und" if the language couldn't be determined.
Whether a password field was found on the page.
URL of the favicon for this page.
The URL of the referrer (indicated by `originator_referring_visit_id`), if any.
Visit has an image derived from public version of the page. This can be used to provide more visual experience.
Categories tagged for the visit.
Related search URLs for a Google SRP visit, to provide next steps to user.
ID of the app (non-BrApp) this entity was generated for, if any. Only visits originating from Android devices may have this set.
Used in:
ID of the category, this typically is an MID.
Weight of the category, this is an integer value informing the confidence of a visit belonging to this category.
Used in:
The core transition type.
Qualifiers: A supervised user tried to access this URL but was blocked.
User used the Forward or Back button to navigate among browsing history.
User used the address bar to trigger this navigation.
User is navigating to the home page.
Used in:
ID of the visit on the originator client, unique within that client.
URL that was visited.
Title of the page corresponding to this URL.
True if the URL should NOT be used for auto-complete.
The redirect type (if any).
(message has no fields)
Response to a history status request.
Minimal time to wait before issuing another request.
Indicates whether the history corpuses have any derived data for a user.
Incoming invitations for password sending.
Used in:
Unique client tag for the invitation. This does *not* have to be the same GUID as for the outgoing invitation.
Profile information about the sender of the password. Sender's public key is used to authenticate the sender for `encrypted_key_for_recipient`.
Encrypted PasswordSharingInvitationData using recipient's public key corresponding to `recipient_key_version` and sender's private key to authenticate the sender, see https://www.rfc-editor.org/rfc/rfc9180.html.
An unsynced field for use internally on the client. This field should never be set in any network-based communications because it contains unencrypted material.
Device specific information telling how to send invalidations to this device.
Used in:
FCM registration token of device (using Sync sender ID).
This device wants to receive only invalidations which are related to these types. The legitimate values of this field correspond to the protobuf field numbers of all EntitySpecifics fields supported by the server (see components/sync/protocol/sync.proto).
A flag to enable support for keystore encryption.
Used in:
Information about a linked app icon.
Used in:
The URL of the app icon.
The size of the app icon in DIPs.
Used in:
Used for encrypting within the sync account boundary.
Serialization of the LoopbackServerEntity and its ancestors.
Used in:
Entity type mapping to one of the subclasses of LoopbackServerEntity.
Used in:
Contains the loopback server state.
The protocol buffer format version.
All Keystore keys known to the server.
The last entity ID that was assigned to an entity.
Properties of managed user setting sync objects.
Used in:
Properties of managed user shared setting sync objects.
Used in:
The MU ID for the managed user to whom the setting applies.
The key of the setting.
The setting value. The setting is a JSON encoding of an arbitrary Javascript value.
This flag is set by the server to acknowledge that it has committed a change to a setting.
Corresponds to a single meta info key/value pair for a bookmark node.
Used in:
Sync proto to store data type global metadata in model type storage.
Used in:
,The latest progress markers received from the server.
A data type context. Sent to the server in every commit or update request. May be updated by either responses from the server or requests made on the model thread. The interpretation of this value may be data-type specific. Many data types ignore it.
This value is set if this type's data should be encrypted on the server. If this key changes, the client will need to re-commit all of its local data to the server using the new encryption key.
Deprecated in M113 and replaced by `initial_sync_state`. As of M115, this is not populated anymore, but existing values are still migrated to `initial_sync_state`. TODO(crbug.com/1423338): Fully remove this field after a migration period.
Indicates the status of "initial sync", i.e. whether the first download cycle and initial merge are complete.
A GUID that identifies the committing sync client. It's persisted within the sync metadata and should be used to check the integrity of the metadata. Mismatches with the guid of the running client indicates invalid persisted sync metadata, because cache_guid is reset when sync is disabled, and disabling sync is supposed to clear sync metadata.
Syncing account ID, representing the user.
The latest unprocessed invalidations received from the server. All incoming invalidations are stored in this message and persist until they are used in GetUpdate() message.
This is relevant for the passwords datatype. This indicates that the initial sync flow (downling all passwords from the server) has been run at least once after the password notes features is enabled. It is used to enforce redownload of passwords upon upgrading the browser to a version that supports password notes if necessary. It is false by default and set to true upon downloading passwords to make sure this download is executed only once.
Used in:
Default value, typically used when there is no metadata (e.g. because Sync is disabled).
Indicates that syncing has started and some, but not all updates from the initial download/sync have been delivered. This is only used for data types in ApplyUpdatesImmediatelyTypes().
Indicates that the initial sync (download + merge) has been completed.
Indicates that no initial sync is necessary, used for CommitOnlyTypes().
Used in:
Opaque field, which has to be provided as part of resulting GetUpdates back to the server.
Version of invalidation, used to order incoming invalidations.
Navigation information for a single redirection within a single navigation.
Used in:
A URL that redirected while navigating to the virtual_url.
Used in:
, ,Note that M78 and before rely on the name being populated, at least for the main encrypted keybag within NigoriSpecifics.
Deprecated: use EncryptionKeys instead.
Used for encrypting data in the user's account.
Sync proto to store Nigori data in storage. Proto should be encrypted with os_crypt before storing it somewhere, because it contains sensitive data ( nigori_model.cryptographer_data.key_bag and nigori_model.keystore_keys).
Global metadata.
Metadata for Nigori entity.
Nigori model state.
Used in:
Represents state of the cryptographer.
Contains the name of the key, used for encryption of NigoriSpecifics.keystore_decryptor_token, should always be the name of the latest keystore key. Equals to cryptographer_data.default_key_name iff it is Nigori in full keystore mode (not in backward compatible keystore mode).
Contains keybag in encrypted form, should be empty once we were able to decrypt keybag from specifics.
PassphraseType used for encryption. IMPLICIT_PASSPRHASE shouldn't be used here.
The time (in UNIX epoch milliseconds) at which the keystore migration was performed.
The time (in UNIX epoch milliseconds) at which a custom passphrase was set. Note: this field may not be set if the custom passphrase was applied before corresponding field in NigoriSpecifics was introduced.
Params used for deriving keys from custom passphrase. Should be set iff |passphrase_type| is CUSTOM_PASSPHRASE.
Indicates whether we need to encrypt all encryptable user types.
The list of encrypted UserEncryptableTypes, represented by their specifics field number.
Keystore keys are used to decrypt keystore-based Nigori. Should be persisted in order to not ask the keystore server for them during every browser startup. Due to backward compatibility requirements keys are always Base64 encoded.
Encryptor keystore decryptor token. Used for decryption of keystore Nigori in case keystore keys arrived after NigoriSpecifics.
Contains the name of the latest available trusted vault key that was used as the default encryption key. Resets when the client go out of pending decryption state and transits to other passphrase types.
Some debug-only fields for passphrase type TRUSTED_VAULT_PASSPHRASE.
Current Public-key.
Properties of nigori sync object.
Used in:
Encrypted proto of type EncryptionKeys.
Once keystore migration is performed, we have to freeze the keybag so that older clients (that don't support keystore encryption) do not attempt to update the keybag. Previously |using_explicit_passphrase|.
Booleans corresponding to whether a datatype should be encrypted. Passwords and Wi-Fi configurations are always encrypted, so we don't need a field here. History delete directives need to be consumable by the server, and thus can't be encrypted. USS clients don't read these values, datatypes are either always encrypted, never encrypted or encrypted when |encrypt_everything| set to true. TODO(crbug.com/1360022): complete deprecation of encrypt_* fields (replace fields with reserved) once <M82 clients aren't supported.
If true, all current and future datatypes will be encrypted.
Enable syncing favicons as part of tab sync.
An |int| field is used instead of enum PassphraseType so we can better handle unknown values coming from later versions. Prior to M77, this was an enum so old clients will assume IMPLICIT_PASSPHRASE for values greater than 4.
The keystore decryptor token blob. Encrypted with the keystore key, and contains the encryption key used to decrypt |encryption_keybag|. Only set if passphrase_state == KEYSTORE_PASSPHRASE.
The time (in milliseconds since Unix epoch) at which the keystore migration was performed.
The time (in milliseconds since Unix epoch) at which a custom passphrase was set. Note: this field may not be set if the custom passphrase was applied before this field was introduced.
Boolean corresponding to whether custom spelling dictionary should be encrypted.
Boolean corresponding to whether app list items should be encrypted.
Boolean corresponding to whether usage count and last use date of Wallet data should be encrypted.
Boolean indicating whether this node was originally missing a |keystore_migration_time| field value, and was fixed on the server by giving the field a value. THIS FIELD SHOULD ONLY BE SET BY THE SERVER.
Boolean corresponding to whether arc pakcage items should be encrypted.
Boolean corresponding to whether printer items should be encrypted.
Boolean corresponding to whether reading list items should be encrypted.
ID of the method used to derive the encryption key from a custom passphrase. Should be set only when |passphrase_type| is CUSTOM_PASSPHRASE and only based on CustomPassphraseKeyDerivationMethod. This field has been added in M70. All previous versions just ignore it, attempt to use PBKDF2_HMAC_SHA1_1003 and, thus, reject any passphrase if a different method has been used. The default corresponds to UNSPECIFIED. An |int| field is used so we can detect unknown values coming from later versions.
Base64-encoded salt used for the derivation of the key from the custom passphrase. Valid only if custom_passphrase_key_derivation_method == SCRYPT_8192_8_11, ignored in other cases.
Boolean corresponding to whether send tab should be encrypted.
Boolean corresponding to whether Web Apps data should be encrypted.
Boolean corresponding to whether OS preferences should be encrypted.
Current cross user sharing Public-key to expose in server registry for sharing offers outside account boundary.
Information useful for auto-upgrade to trusted vault.
Used in:
Current state of an account after it was processed by auto-upgrade.
ID of eligibility group account belongs to. Only use IDs defined within EligibilityGroup enum.
Used in:
Each eligibility group can be ramped in different stages (e.g. 1%, 10%, 100%). Every ramp stage is differentiated with its own entry in the enum.
Used in:
This comes from a <= M69 client, who does not know about the field (but implicitly uses PBKDF2_HMAC_SHA1_1003).
PBKDF2-HMAC-SHA1 with 1003 iterations and constant hardcoded salt. Was implicitly used in <= M69.
scrypt with N = 2^13, r = 8, p = 11 and random salt. Was added in M70.
The state of the passphrase required to decrypt |encryption_keybag|.
Used in:
Proto enums should begin with an 'unknown' value for switch statements, unknown fields, etc.
Gaia-based encryption passphrase. Legacy.
Keystore key encryption passphrase. Uses |keystore_bootstrap| to decrypt |encryption_keybag|.
Previous Gaia-based passphrase frozen and treated as a custom passphrase.
User provided custom passphrase.
Encryption key provided by a trusted vault.
Some debug-only fields for passphrase type TRUSTED_VAULT_PASSPHRASE.
Used in:
,The time (in milliseconds since Unix epoch) at which the trusted vault migration was performed.
The version (aka key epoch) corresponding to the Nigori keybag.
DebugInfo written by a process that auto-upgrades to trusted vault.
The time (in milliseconds since Unix epoch) last update of the auto upgrade debug info was made.
Used in:
Plain text of the note.
Rich text of the note. It will be used when plain_text is empty and the UI supports rich text.
required
required
Used in:
Page target type makes the note global to the page. It does not associate with any user selection.
Properties of a synced Chrome OS system preference. Uses PreferenceSpecifics instead of declaring name and value fields to allow more code sharing in the client (e.g. all PrefModelAssociators can operate on PreferenceSpecifics).
Used in:
Properties of a Chrome OS priority preference. Uses PreferenceSpecifics instead of declaring name and value fields to allow more code sharing in the client (e.g. all PrefModelAssociators can use PreferenceSpecifics).
Used in:
Used for the server to return fine-grained commit errors back to the client.
Used in:
This enum is used in histograms. Entries should not be renumbered and numeric values should never be reused. Also remember to update in tools/metrics/histograms/enums.xml.
Used in:
Sender's public key version is different on the server.
The sender and the recipient are not in the same family according to the Google family service.
Outgoing invitations for password sending.
Used in:
Unique client tag for the invitation, generated by the client.
Recipient's user identifier (obfuscated Gaia ID).
Encrypted PasswordSharingInvitationData using recipient's public key corresponding to `recipient_key_version` and sender's private key to authenticate the sender, see https://www.rfc-editor.org/rfc/rfc9180.html.
An unsynced field for use internally on the client. This field should never be set in any network-based communications because it contains unencrypted material.
Version of Public key of the sender which is used to authenticate the sender of the password. Must be equal to the latest committed version.
All the strings are encoded with UTF-8. URLs are encoded in Punycode.
Used in:
,Used in:
Timestamp set by a client detecting the issue for the first time. Number of microseconds since Windows epoch (1601). This can be unset even if is_muted is set in a few cases in storage (for a time mutes were written without setting this field - fixed starting 2021-11-10).
Whether the issue was muted by user.
Whether the backend should notify the user about this issue. Set to true if the user hasn't already seen a client notification for this issue (e.g. a leak detection prompt in Chrome). The backend sending notifications does not reset this field. All other sources can write this in both `PasswordSpecificsData` and `PasswordSpecificsMetadata` and do so.
Used in:
,Used in:
Contains password fields required for sending. See PasswordSpecificsData for field descriptions.
Used in:
See PasswordSpecificsData::Scheme for values.
A message to obtain a list of recipients for sending a password.
The request returns family members for the user and that is why no additional fields are required.
(message has no fields)
List of possible recipients for sending a password. Note that public key may be absent if a recipient can’t receive a password (e.g. due to an older Chrome version).
Used in:
The user is a member of a family and the request succeeded.
Not a family member, used to distinguish from a family with only one member.
Properties of password sync objects.
Used in:
The actual password data. Contains an encrypted PasswordSpecificsData message.
An unsynced field for use internally on the client. This field should never be set in any network-based communications because it contains unencrypted material.
Password related metadata, which is sent to the server side. The field should never be set for full encryption users. If encryption is enabled, this field must be cleared.
An encrypted backup of the notes field inside the PasswordSpecificsData. The Sync server preserves the contents of this field across commits from legacy clients that don't set this field. It is the responsibility of Sync clients to populate the contents of PasswordSpecificsData notes fields using the contents of this field. This should be deprecated together with the logic for preserving it on the server when clients without support for the |notes| field are no longer allowed by the server (below support version horizon). Encryption key considerations: a) For commits, the client must use the same key for both encrypted blobs. b) For handling getupdates, the two keys may NOT necessarily match the encryption key used, as in theory the new blob could be "behind" if key rotation took place. As of today, it is safe to assume that if |encrypted| is decryptable by a client, then |encrypted_notes_backup| must be decryptable too (i.e. the Nigori keybag should include older versions of the key). But not the other way round. If both `encrypted_notes_backup` and the `notes` in `encrypted` are populated, the one in notes is considered the authoritative value.
Used in:
See the enum above.
Signon realm stores information on where the saved password was stored, and where it's supposed to be filled again. It can take various formats depending on the exact circumstances where it was recorded. Note that the format is *not* guaranteed to be a valid URL or URI: * For parsed web forms and normal passwords saved through Credential Manager API: <http-scheme>://<url-host>[:<url-port>]/ where <http-scheme> is one of "http" or "https" <url-host> is the host for which the password was stored <url-port> is the option port on the host The signon realm is a valid URL in this case with an empty path. Examples: http://www.example.com/ https://127.0.0.1/ http://www.google.com:8080/ http://192.168.1.254/ https://accounts.google.com/ * For Android apps saved through Autofill with Google: android://<hash-of-cert>@<package-name>/ where <hash-of-cert> is the base64 encoded SHA512 of the app's public certificate <package-name> is the app's package name Examples: android://kCyQDzpaoAX2gs-1zdGPKNAeICb8LzRFOxa4NCq0jO8c8d_NFS_q-Y35bU3Nq3GmFV2lLurmNvIZa6YPYZwmWg==@com.pinterest/ android://mNUCvTnoWBkzIhSSkVj-uzAdK42YagmCmyUtPoC6JPmYAN3wKpmTdIRsdJtz6pzNBye8XL7nBbEcx-y9CJeo9A==@com.twitter.android.lite/ * For federated credentials: federation://<origin_host>/<federation_host> where <origin_host> is the host for which the login information was stored <federation_host> is the host of the federation provider that was used to sign in Examples: federation://www.example.com/accounts.google.com federation://uk.trustpilot.com/www.facebook.com * For proxy auth: <proxy-host>[:<proxy_port>]/<auth-realm> where <proxy-host> is the host of the proxy for which the password was stored <proxy-port> is the port of the proxy <auth-realm> is a string provided by the proxy during authentication. It can contain spaces. Examples: proxy2.eq.edu.au:80/MISldap proxy.det.nsw.edu.au:8080/NSW Department of Education 10.47.2.250:3128/Squid Proxy Server CPUT default.go2https.com:443/(******Get password from vpnso.com/account/ *****) * For HTTP basic auth: <http-scheme>://<url-host>[:<url-port>]/<auth-realm> where <http-scheme> is one of "http" or "https" <url-host> is the host for which the password was stored <url-port> is the option port on the host <auth-realm> is a string provided by the host during authentication. It can contain spaces. Examples: http://192.168.1.1/Broadband Router http://192.168.0.1/TP-LINK Wireless N Router WR841N http://192.168.1.1/index.htm https://www.edge.asic.gov.au/ASIC eBusiness
For parsed web forms and Credential Management API: url-scheme://url-host[:url-port]/path For Android: "android://<hash of cert>@<package name>/" For proxy/HTTP auth: url-scheme://url-host[:url-port]/path
Only for web-parsed forms - the action target of the form: url-scheme://url-host[:url-port]/path
Only for web-parsed forms - the name of the element containing username.
For all: the username. For blacklisted forms: <empty>.
Only for web-parsed forms - the name of the element containing password.
For all: the password. For federated logins and blacklisted forms: <empty>
Deprecated: http://crbug.com/413020 True if the credential was saved for a HTTPS session with a valid SSL cert. Ignored for Android apps.
True for the last credential used for logging in on a given site. Deprecated in M81.
Time when the credential was created. Amount of microseconds since 1601.
True, if user chose permanently not to save the credentials for the form.
kFormSubmission(0), user manually filled the username and the password in the form. kGenerated(1), the credential was auto generated. kApi(2), the credential was generated from Credential Management API. kManuallyAdded(3), user manually created the password credential via Settings. kImported(4), the credential was imported using the import flow. kReceivedViaSharing(5), the credential has been received via the password sharing feature.
Number of times this login was used for logging in using an HTML form. Chrome uses this field to distinguish log-in and sign-up forms.
A human readable name of the account holder. Set by CredentialManager API and Android.
A URL of the avatar for the credential. Set by CredentialManager API and Android.
A URL of the IdP used to verify the credential. Set by Credential Manager API and Android.
Time when the credential was last used. This covers *successful* logins to the website, and explicit updates to the password. It does *not* cover if the password just gets filled but not actually submitted, or if the login failed. Note that password consumers other than Chrome (e.g. Google Play Services) might not update this at all. Amount of microseconds since 1601, aka Windows epoch.
Set if an issue was detected that puts this password at risk. All the clients are expected to clear the field when the password value is updated. 'reused' part can be additionally reset when the analysis on the entire password store is completed.
Time when the |password_value| was last modified. For new credentials it should be set to |date_created|. For subsequent updates the timestamp is changed if and only if the new password value was saved. Number of microseconds since Windows epoch (1601).
Set of extra notes that the user attached to the password. The presence of this field, even with an empty Notes message, becomes the authoritative value for notes and would disregard whatever `encrypted_notes_backup` contains.
For credentials that have been shared by another user, this field captures the sender email. It's empty for credentials that weren't received via password sharing feature.
Similar to `sender_email` but for the sender name.
The timestamp when the password was received via sharing feature from another user.
Whether the user has been already notified that they received this password from another user via the password sharing feature. This is synced to avoid showing the notification on multiple devices.
Similar to `sender_email` but for the url of the sender profile image.
Used in:
Used in:
The display name must be unique within the scope of a password.
The user-defined value of the note.
The creation time of the note. Number of microseconds since 1601.
Whether the value of the note is not displayed in plain text by default.
The different types of the saved credential.
SCHEME_HTML, the credential represents either a parsed HTML form, or an android credential or a password saved through Credential Management API (https://w3c.github.io/webappsec/specs/credentialmanagement/).
SCHEME_BASIC, basic access http authentication.
SCHEME_DIGEST, digest access authentication.
SCHEME_OTHER, another proxy access authentication.
USERNAME_ONLY, partial credentials saved on Android that contain only username and miss the password.
Contains the password specifics metadata which simplifies its lookup.
Used in:
The signon realm for the credential. For more details, see the `signon_realm` field in PasswordSpecificsData.
True, if user chose permanently not to save the credentials for the form. Introduced in M82. Copy from PasswordSpecificsData.blacklisted.
Copy from PasswordSpecificsData.date_last_used. Introduced in M112.
Copy from PasswordSpecificsData.password_issues. Introduced in M114.
Copy from PasswordSpecificsData.type. Introduced in M119.
Contains information of payment instruments that can be used by the user.
Used in:
Opaque identifier for the account stored in Payments Platform. This will be used to initiate the payment.
The supported rails for which a payment can be made for the given account. For example, Pix is the open-banking rail in Brazil, UPI is the open-banking rail in India.
The URL for the image to be displayed when showing the account to the user.
Nickname for the instrument.
The backing source for the applicable rails.
Supported payment infrastructures (rail) that allow users to send money between the payer and the payee. https://en.wikipedia.org/wiki/Payment_rail
Used in:
Payment rails for Brazil Open Banking.
International Bank Account Numbers.
Contains information about a Payments Customer.
Used in:
The billable customer ID associated with the account.
Sync proto to store entity data similar to what the legacy Directory used to store, used to persist data locally and never sent through the wire. Because it's conceptually similar to SyncEntity (actual protocol) and it's unclear how big this'll grow, we've kept compatibility with SyncEntity by using the same field numbers.
See corresponding fields in SyncEntity for details.
Used in:
The encoded tunnel server in the same format as in the BLE advert. See device::cablev2::tunnelserver::DecodeDomain. (Actually a uint16 but proto doesn't have that as a type.)
An FCM token that can be presented to the tunnel server to contact this device.
A shared secret key, used to enable communication across devices via unauthenticated channels. Knowledge of this secret acts as proof that the remote end is authorized to talk to the device publishing this secret.
An id that identifies |secret|. This, and |secret|, will be rotated and the ID allows this device to know which |secret| the counterparty is using.
A P-256, X9.62-encoded public key for this device. Specific to the Chrome instance.
The credential ID for use when signing into accounts.google.com. This credential ID isn't published as a WebauthnCredentialSpecifics, unlike other passkeys, because it's auto-generated.
Used in:
A stable, unique identifier, generated by the PlusAddress backend.
The origin that the `plus_email` is generated for.
Used in:
Used in:
required
required
required
required
required
required
PowerType is persisted to disk and therefore shouldn't be reoderered or changed. Should keep the field numbers of PowerType in sync with the ones in entity above.
Used in:
All powers should have type so this should be unused.
Used for testing.
Used for notes.
Data structure dedicated to each power type. Should keep the field numbers of specifics in sync with the ones in PowerType below.
Used in:
Used for notes.
Flags for enabling the experimental no-precommit GU feature.
Used in:
Properties of preference sync objects.
Used in:
, , ,User PPD configuration
Used in:
Url for user provided file. Overrides other fields.
Retired fields
String identifying the type of printer, used to look up a ppd to drive the printer.
True if the printer should be automatically configured, false otherwise.
Used in:
Printer record GUID
User visible name. Any string.
User visible description. Any string.
Printer manufacturer. Should be a known manufacturuer. Deprecated in favor of make_and_model.
Printer model. Should match a known model for the manufacturer. Deprecated in favor of make_and_model.
Universal Resource Identifier for the printer on the network. usb:// will be the scheme for USB printers. Example ipp://address.example:port/queue/queue/queue.
Universally Unique Identifier provided by the printer. Used for unique identification of printers in a zeroconf environment.
PPDData was deprecated in favor of PPDReference format.
Structure representing the user's ppd configuration.
Timestamp when printer was last updated.
The make and model of the printer in one string. The typical arrangement for this is '<make> <model>'. This aligns with the typical formatting of the IPP attribute printer-make-and-model.
Universal Resource Identifier for the print server on the network. This will only be populated if the printer is from a print server. Example ipp://address.example:port/
Represents trusted Authorization Server for printers.
Used in:
Universal Resource Identifier for the authorization server on the network. The scheme must be https. Example: https://address.example:port/path/path. This field must be unique and is required.
Properties of a synced priority preference.
Used in:
Sync Reading list entry. This proto contains the fields synced for a reading list entry. It must be kept synced with the reading_list.ReadingListLocal protobuf.
Used in:
entry_id and url must be equal.
If the field is not present, it defaults to UNSEEN.
Used in:
Subset of TabNavigation fields representing a navigation that was later replaced in history (e.g. history.replaceState()), which allows tracking information about the original navigation prior to the first replacement.
Used in:
Sync protocol datatype extension for saved tab groups. Saved Tab Groups are tab groups which can be recalled between browser sessions, and if sync is turned on, cross device. A saved tab group contains tabs which are stored as a SavedTabGroupSpecifics separately (SavedTabGroupTab). This is due to limitations from the sync service on the size of an individual sync entity.
Used in:
The position of the SavedTabGroup in any visual display. This also represents the index in the SavedTabGroupModel of the group.
The displayed title of the group, shown on the tab group and the saved tab group button.
The color of the group, mapped to tab_groups::TabGroupColorId.
These colors map to tab_groups::TabGroupColorId. They DO NOT match the enum integer values due to "kGrey" being in the "Unspecified" field.
Used in:
Used in:
An id that refers to the sync saved tab group object.
Timestamps for CRUD operations.
Sync protocol datatype extension for saved tab group tabs. SavedTabGroupTab are the sync representation of a tab in a saved tab group. they are stored as separate entities due to size limitations of sync entities.
Used in:
An id that links the saved tab group tab to it's saved tab group.
The position in the Tab Strip the tab is located relative to the start of the tab group. This is also the index in the saved_tabs_ vector in the SavedTabGroup in the SavedTabGroupModel, which is updated by the TabStripModel.
Tab Data used for constructing the tab.
The displayed title of the tab, shown on the saved tab group button's context menu.
Properties of custom search engine sync objects.
Used in:
The description of the search engine.
The search engine keyword for omnibox access.
A URL to the favicon to show in the search engines options page.
The actual parameterized search engine query URL.
A flag signifying whether it is safe to automatically modify this search engine entry or not.
The URL to the OSD file this search engine entry came from.
The date this search engine entry was created. A UTC timestamp with units in microseconds.
A list of supported input encodings.
Obsolete field. This used to represent whether or not this entry is shown in the list of default search engines.
The parameterized URL that provides suggestions as the user types.
The ID associated with the prepopulate data this search engine comes from. Set to zero if it was not prepopulated.
DEPRECATED: Whether to autogenerate a keyword for the search engine or not. Do not write to this field in the future. We preserve this for now so we can read the field in order to migrate existing data that sets this bit.
ID 13 reserved - previously used by |logo_id|, now deprecated.
ID 16 reserved - previously used by |id|, now deprecated. The last time this entry was modified by a user. A UTC timestamp with units in microseconds.
The primary identifier of this search engine entry for Sync.
A list of URL patterns that can be used, in addition to |url|, to extract search terms from a URL.
The parameterized URL that provides image results according to the image content or image URL provided by user.
The following post_params are comma-separated lists used to specify the post parameters for the corresponding search URL.
The parameterized URL for a search provider specified new tab page.
Whether a search engine is 'active' and can be triggered via the omnibox by typing in the relevant keyword.
The ID associated with the starter pack engine. This is set to 0 if not a starter pack engine.
Used in:
The default state when a SE is auto-added. Unspecified SE are inactive.
The SE is active and can be triggered via the omnibox.
The SE has been manually set to inactive by the user.
Used in:
The specific security event to record.
Time of event, as measured by client in microseconds since Windows epoch.
Sync data proto for storing segmentation data. Keyed by the combination of cache_guid (a Sync client id) and segmentation key. The segmentation platform is a platform that uses intelligence and machine learning to guide developers for building purpose-built user experience for specific segments of users. See go/chrome-segmentation for more details.
Used in:
The key used to identify the type of segmentation associated with a feature, e.g. 'user_engagement'.
One or more model execution data associated with each segment for the segmentation key.
Metadata about the client device as used by the segmentation platform.
Used in:
The cache_guid created to identify a sync client on this device. Reuses the same Sync guid.
The OS platform of the device.
Used in:
Model execution data including segment scores and related metadata, e.g., model version.
Used in:
A string ID that identifies a model.
A model may output one or multiple scores, one score for each segment label.
Timestamp when the ML model was executed. Represents time from windows epoch in seconds.
Expiry timestamp for the model scores. Represents time from windows epoch in seconds.
The version of the ML model that was run.
Output of model.
Used in:
When outputting multiple scores from a single model, this is the segment label for each output.
Raw segment scores provided by the ML model or the heuristic model. The score is derived based on a combination of UMA histograms, user actions or UKM and URLs visited. The score can be treated as a probability of the user liking a feature, like feed, or NTP.
A rank defined by the segmentation scheme.
The selected segment by the segmentation scheme.
Used in:
The string ID that refers to the segment the user was assigned to, e.g., 'highly_engaged_user'.
Expiry time of selection result. Represents time from windows epoch in seconds. Expired results are ignored by clients.
Time when the segmentation data is updated. Used to weigh results by recency. Represents time from windows epoch in seconds.
Send Tab To Self list entry. This proto contains the fields synced to send a url across devices.
Used in:
A random unique identifier for each shared tab. Required.
The name of the tab being shared.
The URL of the tab being shared. Required.
The time the tab was shared as measured by the client in microseconds since the windows epoch.
A non-unique but human readable name to describe this client, used in UI.
The stable Device_id of the device that this tab was shared with. Required.
A boolean to designate if the shared tab been opened on the target device.
Whether the notification for this proto been dismissed.
Properties of session sync objects.
Used in:
Each session is composed of windows.
A non-unique but human-readable name to describe this client.
The form factor of device.
The type of device. Mandatory until M115. Replaced by device_form_factor afterwards, but still populated for backward compatibility.
Used in:
Unique id for the client. M89 and higher use sync's cache GUID (client ID) to populate this tag for *new* sessions.
The local tab id used by sync. Unique across all nodes for that client.
Used in:
Unique (to the owner) id for this tab.
The unique id for the window this tab belongs to.
Visual index of the tab within its window. There may be gaps in these values.
Identifies the index of the current navigation in navigations. For example, if this is 2 it means the current navigation is navigations[2].
True if the tab is pinned.
If non-empty, this tab is an app tab and this is the id of the extension.
Tabs are navigated, and the navigation data is here.
Timestamp for when this tab was last activated. Corresponds to WebContents::GetLastActiveTime().
The favicon for the current url the tab is displaying. Either empty or a valid PNG encoded favicon.
The url of the actual favicon (as opposed to the page using the favicon).
Ids of the currently assigned variations which should be sent to sync.
The type of favicon. For now only normal web favicons are supported.
Used in:
Used in:
Unique (to the owner) id for this window.
Index of the selected tab in tabs; -1 if no tab is selected.
Type of the window.
The tabs that compose a window (correspond to tab id's).
Used in:
The URL of the page.
The title of the page.
The URL to the favicon of the page.
The GUID of the SharedTabGroup this is a member of.
The UniquePosition within a SharedTabGroup.
Used in:
The displayed title of the group, shown on the tab group.
The color of the tab group, mapped to tab_groups::TabGroupColorId.
These colors map to tab_groups::TabGroupColorId. They DO NOT match the enum integer values due to "kGrey" being in the "Unspecified" field.
Used in:
Used in:
Unique identifier for this entity.
TODO(b/319521964): consider to rename and add a comment to clarify the content.
Used for the server to return fine grained commit errors back to the client.
Used in:
This enum is used in histograms. Entries should not be renumbered and numeric values should never be reused. Also remember to update in tools/metrics/histograms/enums.xml SyncSharingMessageCommitErrorCode enum.
Used in:
Client-specific error codes.
Deprecated UMA bucket, prior to splitting between SYNC_SERVER_ERROR and SYNC_AUTH_ERROR.
Message wasn't committed before timeout.
Error code for server error or unparsable server response.
Auth error when communicating with the server.
Used in:
Unique identifier of message.
Payload encrypted using the target user keys according to WebPush encryption scheme. The payload has to be a valid chrome/browser/sharing/proto/sharing_message.proto serialized using SerializeToString.
Used in:
FCM channel configuration. Message will be delivered as a FCM message.
Opaque server channel configuration. Message will be delivered through server channel.
Used in:
FCM registration token of target device.
Time to live for a FCM message (in seconds) - if specified, the message will expire based on the TTL.
Priority level of a FCM message. 5 = normal, 10 = high.
Device specific information for Sharing feature. Used to send end-to-end encrypted message through FCM to other devices.
Used in:
FCM registration token of device subscribed using VAPID key. TODO(crbug.com/1012226): Deprecate when VAPID migration is over.
Public key for message encryption [RFC8291] using VAPID key. TODO(crbug.com/1012226): Deprecate when VAPID migration is over.
Auth secret for message encryption [RFC8291] using VAPID key. TODO(crbug.com/1012226): Deprecate when VAPID migration is over.
A list of enabled Sharing features.
Deprecated. Use sender_id_fcm_token_v2 for new clients.
Deprecated. Use sender_id_p256dh_v2 for new clients.
Deprecated. Use sender_id_auth_secret_v2 for new clients.
FCM registration token of device subscribed using Sharing sender ID.
Public key for message encryption [RFC8291] using Sharing sender ID.
Auth secret for message encryption [RFC8291] using Sharing sender ID.
Enum defining available Sharing features.
Used in:
Supports Click to Call only via VAPID.
Supports Shared Clipboard only via VAPID.
Suppots Click to Call via both VAPID and sender ID.
Suppots Shared Clipboard via both VAPID and sender ID.
Supports optimization guide push notification.
The additional info here is from the StatusController. They get sent when the event SYNC_CYCLE_COMPLETED is sent.
Used in:
These new conflict counters replace the ones above. TODO(crbug.com/1315573): Deprecated in M103.
No longer sent since M24.
Counts to track the effective usefulness of our GetUpdate requests.
TODO(crbug.com/1315573): Deprecated in M103.
|caller_info| was mostly replaced by |get_updates_origin|; now it only contains the |notifications_enabled| flag.
A message indicating that the sync engine has been disabled on a client.
Used in:
The GUID that identifies the sync client.
The store birthday that the client was using before disabling sync.
Used in:
, ,This item's identifier. In a commit of a new item, this will be a client-generated ID. If the commit succeeds, the server will generate a globally unique ID and return it to the committing client in the CommitResponse.EntryResponse. In the context of a GetUpdatesResponse, |id_string| is always the server generated ID. The original client-generated ID is preserved in the |originator_client_id| field. Present in both GetUpdatesResponse and CommitMessage. Prior to M123, this field was empty for commit-only types.
An id referencing this item's parent in the hierarchy. In a CommitMessage, it is accepted for this to be a client-generated temporary ID if there was a new created item with that ID appearing earlier in the message. In all other situations, it is a server ID. Present in both GetUpdatesResponse and CommitMessage. Starting with M99, this field is optional and used for legacy bookmarks only: 1. When processing GetUpdatesResponse, it is unused for modern data created or reuploaded by M94 or above, which populates the parent's GUID in BookmarkSpecifics (which is sufficient). 2. When issuing CommitMessage, the field is populated for compatibility with clients before M99.
The version of this item -- a monotonically increasing value that is maintained by for each item. If zero in a CommitMessage, the server will interpret this entity as a newly-created item and generate a new server ID and an initial version number. If nonzero in a CommitMessage, this item is treated as an update to an existing item, and the server will use |id_string| to locate the item. Then, if the item's current version on the server does not match |version|, the commit will fail for that item. The server will not update it, and will return a result code of CONFLICT. In a GetUpdatesResponse, |version| is always positive and indentifies the revision of the item data being sent to the client. Present in both GetUpdatesResponse and CommitMessage. WARNING: This field used to be required before M60. Any client before this will fail to deserialize if this field is missing.
Last modification time, in milliseconds since Unix epoch. Present in both GetUpdatesResponse and CommitMessage.
Creation time, in milliseconds since Unix epoch. Present in both GetUpdatesResponse and CommitMessage.
The name of this item. Historical note: Since November 2010, this value is no different from non_unique_name. Before then, server implementations would maintain a unique-within-parent value separate from its base, "non-unique" value. Clients had not depended on the uniqueness of the property since November 2009; it was removed from Chromium by http://codereview.chromium.org/371029 . Present in both GetUpdatesResponse and CommitMessage. WARNING: This field used to be required before M60. Any client before this will fail to deserialize if this field is missing.
The name of this item. Same as |name|. |non_unique_name| should take precedence over the |name| value if both are supplied. For efficiency, clients and servers should avoid setting this redundant value. Present in both GetUpdatesResponse and CommitMessage.
If present, this tag identifies this item as being a uniquely instanced item. The server ensures that there is never more than one entity in a user's store with the same tag value. This value is used to identify and find e.g. the "Bookmark Bar" folder without relying on a particular ID or name. This variant of the tag is created by the server, so clients can't create an item with a tag using this field. Use client_tag_hash if you want to create one from the client. An item can't have both a client_tag_hash and a server_defined_unique_tag. Present only in GetUpdatesResponse.
Ancient fields, predecessors for |unique_position|, deprecated with M26 and still supported to deal with old incoming data. See field |unique_position| for details as well as the data-upgrading implementation in GetUniquePositionFromSyncEntity().
If true, indicates that this item has been (or should be) deleted. Present in both GetUpdatesResponse and CommitMessage.
A unique ID that identifies the the sync client who initially committed this entity. This value corresponds to |cache_guid| in CommitMessage. This field, along with |originator_client_item_id|, can be used to reunite the original with its official committed version in the case where a client does not receive or process the commit response for some reason. Present only in GetUpdatesResponse. This field is also used in determining the unique identifier used in bookmarks' unique_position field.
Item ID as generated by the client that initially created this entity. Used exclusively for bookmarks (other datatypes use client_tag_hash). There are three generation of bookmarks that have populated this field differently, depending on which version of the browser created the bookmark: 1. For bookmarks created before M44 (2015), the field got populated with an ID that is locally unique, but not globally unique (usually a negative number). 2. For bookmarks created between M45 and M51, both inclusive, the field got populated with a globally unique GUID in uppercase form. 3. For bookmarks created with M52 or above, the field gets populated with a globally unique GUID in lowercase form. Present only in GetUpdatesResponse.
Extensible container for datatype-specific data. This became available in version 23 of the protocol.
Indicate whether this is a folder or not. Available in version 23+.
A client defined unique hash for this entity. Analogous to server_defined_unique_tag, but allows the client to determine an immutable attribute of the entity in hashed form that makes it unique per user (i.e. at most one entity may exist per client tag hash). This value must be of the form base64(SHA1(client_tag)) where the client_tag is a value derived from the contents of an entity in a type-specific way. Since the hashed contents of the client_tag are exposed to the server via this field, take care when defining it that there is enough entropy to mask any secrets that the server shouldn't learn. The difference between server_defined_unique_tag and client_tag_hash is the creator of the entity. Server defined tags are entities created by the server at account creation, while client defined tags are entities created by the client at any time. During GetUpdates, a sync entity update will come back with ONE of: a) Originator item and cache id - for bookmarks created using old versions of the browser (latest M93, before https://crrev.com/c/2945119). b) Server tag - If server committed the item as unique c) Client tag - If client committed the item as unique May be present in CommitMessages for the initial creation of an entity. If present in Commit updates for the entity, it will be ignored. May be returned in GetUpdatesMessage and sent up in CommitMessage.
Introduced in M26, represents ordering among entities, in practice used for bookmarks only. Clients should not assume it is always populated in GetUpdatesMessage due to the following caveats: 1. Tombstones and permanent folders do not populate it (ordering is irrelevant). 2. It may remain unset by future versions of the client, as long as the field with the same name is populated inside BookmarkSpecifics. M94 and above populate both for backward compatibility reasons, but when support for M93 is retired, modern clients at the time may stop populating this field. 3. Very old data (last committed by M25 or below, before the field was introduced) does not include this field, and in that case the legacy fields |position_in_parent| or |insert_after_item_id| must be honored instead. May be returned in GetUpdatesMessage and sent up in CommitMessage.
Metadata used for shared data types. Must not be present for regular data types. Introduced in M124.
Used in:
Collaboration ID which the current entity belongs to.
(message has no fields)
Used in:
Upgrade the client to latest version.
DEPRECATED_CLEAR_USER_DATA_AND_RESYNC = 1; DEPRECATED_ENABLE_SYNC_ON_ACCOUNT = 2; DEPRECATED_STOP_AND_RESTART_SYNC = 3; DEPRECATED_DISABLE_SYNC_ON_CLIENT = 4;
This is the default.
Types of browsers; used for history-related data types.
Used in:
, ,A normal tabbed window.
A popup window.
A custom tab within an app.
Types of device form factors.
Used in:
, ,New enums to describe the device type were introduced; OsType and FormFactor. Deprecated 12/2022. TODO(1395353): Remove deprecated values from DeviceType enum.
Used in:
,Used in:
,DEPRECATED_ACCESS_DENIED = 1; Returned when the server and client disagree on the store birthday. This should be interpreted as all local sync metadata requiring cleanup, obviously including the locally-cached store birthday.
Returned when the store has exceeded the allowed bandwidth utilization.
DEPRECATED_AUTH_EXPIRED = 4; DEPRECATED_USER_NOT_ACTIVATED = 5; DEPRECATED_AUTH_INVALID = 6; DEPRECATED_CLEAR_PENDING = 7; A transient error occurred (e.g. a backend timeout). The client should try again later.
A server-side migration has taken place for one or more data types. The client should clear the cache for these data types only and then re-sync with a server.
An administrator disabled sync for this domain.
Deprecated in M50. DEPRECATED_USER_ROLLBACK = 11; Returned when the client wants to update several data types, but some of them failed (e.g. throttled).
Returned when the server detects that this client's sync metadata is obsolete. The client should reset local sync metadata and restart syncing.
Returned when the server detects that the encryption state (Nigori, keystore keys) has been reset/overridden, which means the local Nigori-related state is obsolete and should be cleared. Introduced in M84.
Unknown value. This should never be explicitly used; it is the default value when an out-of-date client parses a value it doesn't recognize.
This is the successor to GetUpdatesSource. It merges the "normal mode" values (LOCAL, NOTIFICATION and DATATYPE_REFRESH), which were never really mutually exclusive to being with, into the GU_TRIGGER value. It also drops support for some old values that are not supported by newer clients. Mind the gaps: Some values are intentionally unused because we want to keep the values in sync with GetUpdatesSource as much as possible. Please don't add any values < 12 unless there's a good reason for it. Introduced in M28.
Used in:
,The source was not set by the caller.
The source of the update was periodic polling.
The client is in configuration mode
because it's syncing all datatypes, and support for a new datatype was recently released via a software auto-update.
The client is in configuration mode because a
MIGRATION_DONE error previously returned by the server necessitated resynchronization.
The client is in configuration mode because the
user enabled sync for the first time. Not to be confused with FIRST_UPDATE.
The client is in configuration mode because the
user opted to sync a different set of datatypes.
The client is in 'normal' mode. It may have several
reasons for requesting an update. See the per-type GetUpdateTriggers message for more details.
A retry GU to pick up updates missed by last GU due to
replication delay, missing hints, etc.
A GU to programmatically enable/disable a
Types of device OS.
Used in:
Types of transitions between pages.
Used in:
, ,The below two were mistakenly added but never properly used. They are actually transition qualifiers, and are set independently of other qualifiers and of the main transitions. See session_specifics.proto for the list of synced transition qualifiers. DEPRECATED_CHAIN_START = 12; DEPRECATED_CHAIN_END = 13;
Types of redirects that triggered a transition.
Used in:
,The "password state" is the presence/absence of a password field on a website; used for history-related data types.
Used in:
,These events are sent by the DebugInfo class for singleton events.
Used in:
Connection status change. Note this gets generated even during a successful connection.
Client received an updated token.
Cryptographer needs passphrase.
Passphrase was accepted by cryptographer.
Sync Initialization is complete.
Server sent stop syncing permanently. This event should never be seen by the server in the absence of bugs.
Client has finished encrypting all data. DEPRECATED_ENCRYPTION_COMPLETE = 7; Client received an actionable error.
Set of encrypted types has changed.
The encryption passphrase state changed.
A new keystore encryption token was persisted. Deprecated 11/2021.
The datatype manager has finished an at least partially successful configuration and is once again syncing with the server.
A new cryptographer bootstrap token was generated.
Cryptographer needs trusted vault decryption keys.
Cryptographer no longer needs trusted vault decryption keys.
The payload coming from the server for all invalidated data types.
This field contains information about each data type which needs to be updated. Note that it may contain data types which current client is not interested in.
Opaque field, which has to be provided as part of resulting GetUpdates back to the server.
Version of invalidation, used to order incoming invalidations.
Used in:
The legitimate values of this field correspond to the protobuf field numbers of all EntitySpecifics fields supported by the server (see components/sync/protocol/sync.proto).
Used in:
The virtual URL, when nonempty, will override the actual URL of the page when we display it to the user.
The referring URL, which can be empty.
The title of the page.
The core transition type.
If this transition was triggered by a redirect, the redirect type.
The unique navigation id (within this client).
Timestamp for when this navigation last occurred (in client time). If the user goes back/forward in history the timestamp may refresh.
User used the Forward or Back button to navigate among browsing history.
User used the address bar to trigger this navigation.
User is navigating to the home page.
The id for this navigation, which is globally unique with high probability.
The favicon url associated with this page.
The status code from the last navigation.
Correct referrer policy. Valid enums are defined in third_party/WebKit/public/platform/WebReferrerPolicy.h.
Whether the Password Manager saw a password field on the page.
The start/end of a redirect chain. Deprecated in M108 because they were always set to false in practice, and don't make sense in the first place - this message corresponds to a complete chain.
Search terms extracted from the URL. Deprecated in M64.
Whether access to the URL was allowed or blocked. Deprecated in M121 because it was unused.
Referrer policy. Old, broken value. Deprecated in M61.
True if created from restored navigation entry that hasn't been loaded. Deprecated in M121 because it was unused.
The chain of redirections for this navigation, from the original URL through the last URL that redirected. Deprecated in M121 because it was unused.
The last URL traversed when different from the virtual_url. Deprecated in M121 because it was unused.
The id for the task associated with this navigation, which is globally unique with high probability. Deprecated in M121 because it was unused.
Task ids of all ancestor navigations, which can be from other tabs, from root to parent. Deprecated in M121 because it was unused.
When a history entry is replaced (e.g. history.replaceState()), this contained some information about the entry prior to being replaced. Deprecated in M121 because it was unused.
The page language as determined by its textual content. An ISO 639 language code (two letters, except for Chinese where a localization is necessary). Deprecated in M121 because it was unused.
Used in:
Properties of theme sync objects.
Used in:
If set, we're using a extension and all custom_* fields should be present. If not set, and all custom_* fields should be omitted.
This field is only relevant on platforms that have a distinction between the system theme and the default theme, but other platforms must be careful to pass through the value of this flag. If true, we use the system theme by default (i.e., when we don't use a custom theme) for platforms that make a distinction between the default theme and the system theme. Has no effect if use_custom_theme is true.
TODO(gayane): Migrate custom_* fields to a separate message. Extension specific fields. Ignored if |autogenerated_theme| is set.
If set, autogenerated theme is used.
Used in:
SkColor used to autogenerate theme.
Both fields below must be filled in. Otherwise, this delete directive must be ignored.
Used in:
The time on or after which entries must be deleted.
The time on or before which entries must be deleted.
Optional field to filter the entries with the matching app ID. This field is set only by Android which has app-specific history feature that allows users to generate/delete history entries from Custom Tabs on app, not from BrApp.
Per-type hint information.
The data type this hint applied to.
Whether or not a valid hint is provided.
Properties of typed_url sync objects - fields correspond to similarly named fields in history::URLRow.
Used in:
Actual URL that was typed.
Title of the page corresponding to this URL.
True if the URL should NOT be used for auto-complete.
Timestamps for all visits to this URL.
The PageTransition::Type for each of the visits in the |visit| array. Both arrays must be the same length.
A UniquePosition is a string of bytes. Unique positions are unique per-item, since they are guaranteed to end with a fixed-length suffix that is unique per-item. The position string may not end with a '\0' byte. Prior to the suffix is a series of arbitrary bytes of arbitrary length. Items under the same parent are positioned relative to each other by a lexicographic comparison of their UniquePosition values.
History: Unique positions were first introduced in M28. This change was rolled out in such a way that it would try to maintain backwards compatibilty with clients that understood only the old int64-based positions. At first, clients supported only the 'value' field. This version never made it to stable. We later added support for the 'compressed_value' field, and clients would populate either one or the other. In M30, we added the custom_compressed_v1 representation. This representation was better than the previous implementations in almost every way. However, we could not use it right away, since older clients would not understand it. We decided to write both the old-style ('value' or 'custom_compressed') representation and the 'custom_compressed_v1' repersentations to every protobuf during the transition period. Protobufs written during this transition period would be readable by clients who understand at least one of the two formats. In M33, we dropped support for writing the backwards-compatibility fields. Protobufs written by this version or later are not be intelligible by clients with version M29 or older. Those clients will end up making use of the old int64 position fallback mechanism.
Used in:
, , ,The uncompressed string of bytes representing the position. Deprecated. See history note above.
The client may choose to write a compressed position to this field instead of populating the 'value' above. If it chooses to use compression, the 'value' field above must be empty. The position value will be compressed with gzip and stored in the compressed_value field. The position's uncompressed length must be specified and written to the uncompressed_length field. Deprecated. See history note above.
This encoding uses compression scheme designed especially for unique positions. It has the property that X < Y precisely when Compressed(X) < Compressed(Y), which is very useful when the most common operation is to compare these positions against each other. Their values may remain compressed in memory. The compression scheme is implemented and documented in sync/core_impl/base/unique_position.cc. As of M30, this is the preferred encoding. Newer clients may continue to populate the 'value' and 'compressed_value' fields to ensure backwards compatibility, but they will always try to read from this field first.
Both fields below must be filled in. Otherwise, this delete directive must be ignored.
Used in:
The URL that should be removed from history.
The time on or before which entries must be deleted. In microseconds since the Unix epoch.
Optional field to filter the entries with the matching app ID. This field is set only by Android which has app-specific history feature that allows users to generate/delete history entries from Custom Tabs on app, not from BrApp.
Next id: 17
=========================================================================== Fields common to all Chrome User Consents. ===========================================================================
Used in:
The UI language Chrome is using, represented as the IETF language tag defined in BCP 47. The region subtag is not included when it adds no distinguishing information to the language tag (e.g. both "en-US" and "fr" are correct here).
The local time on the client when the user consent was recorded. The time as measured by client is given in microseconds since Windows epoch. This is needed since user consent recording may happen when a client is offline.
The account ID of the user who gave the consent. This field is used by UserEventService to distinguish consents from different users, as UserConsent does not get deleted when a user signs out. However, it should be cleared before being sent over the wire, as the UserEvent is sent over an authenticated channel, so this information would be redundant. For semantics and usage of the |account_id| in the signin codebase, see IdentityManager::GetPrimaryAccountId() or CoreAccountId.
Ids of the strings of the consent text presented to the user.
Id of the string of the UI element the user clicked when consenting.
Was the consent for |feature| given or not given (denied/revoked)?
Which feature does the consent apply to?
Used in:
TODO(markusheintz): ASSISTANT_ACTIVITY_CONTROL was only added for compatibility with the Feature enum in UserEventSpecifics.UserConsent. Delete this value once the value is deleted from the other proto.
(message has no fields)
The User Consent for downloading and using passwords stored in the user's Google Account. Determined during the opt-in flow for the feature.
Used in:
Ids of the strings of the consent text presented to the user.
Id of the string of the UI element the user clicked in order to confirm the consent dialog.
The status of the consent. This specifies whether the consent was given or not given/revoked.
The user consent for the ARC Backup And Restore feature. The consent status is determined by the corresponding setting on the ARC setup dialog.
Used in:
Ids of the strings of the setting text presented to the user.
Id of the string of the UI element the user clicked when consenting.
The user consent for the Google Location Service. The consent status is determined by the corresponding setting on the ARC setup dialog.
Used in:
Ids of the strings of the setting text presented to the user.
Id of the string of the UI element the user clicked when consenting.
The user consent for the Play terms of service is determined by the user action on the ARC setup dialog that presents the Play Terms of Service.
Used in:
The length of the UTF-8 encoded string of the Play Terms of Service text. The length is given in number of bytes.
The SHA1 hash of UTF-8 encoded string of the Play Terms of Service displayed to the user.
GRD Ids of the strings on the consent UI that was shown to the user.
Id of the string of the UI element the user clicked when consenting.
The status of the Play Terms of Service consent. This specifies whether the consent was given or not given/revoked.
The user flow during which the consent was recorded. This is necessary in order to create the correct UI context and Event for the backend.
Enum describing different user flow during which the ARC Play Terms of service consent can be recorded.
Used in:
The ARC setup flow on a CROS device.
The user flow for changing the ARC setting on a CROS device.
The User Consent for Assistant activity control is determined by the user action on the Assistant opt-in flow.
Used in:
An opaque token to for ui auditing, which strengthens the audit trail.
The status of the Assistant activity control consent. This specifies whether the consent was given or not given.
The activity control setting which the consent was given or not given to. Clients before M93 did not set this field. Such consents should be treated as applying to ALL.
Enum denoting different Assistant activity control setting type.
Used in:
Legacy clients (< M93) did not set a SettingType; for those, UNSPECIFIED should be interpreted as ALL. Newer clients should always set it explicitly.
All Settings.
The status of a particular User Consent. The status describes the state of the consent as it is: given, not_given.
Used in:
, , , , , , ,The status is unspecified e.g. because the user was not asked to consent yet or an error happened or the decision was delayed.
The consent is not given. This means the user either revoked the consent or did not grant it in the first place.
The consent is given. This means the user did grant the consent.
The User Consent for Chrome Sync is determined by the user action on the corresponding Sync Consent dialog.
Used in:
Ids of the strings of the sync consent text presented to the user.
Id of the string of the UI element the user clicked in order to confirm and close the sync consent dialog.
The status of the sync consent. This specifies whether the consent was given or not given/revoked.
The unified User Consent for Chrome is determined by the user action on the corresponding Chrome Consent dialog.
Used in:
Ids of the strings of the unified Chrome consent text presented to the user.
Id of the string of the UI element the user clicked in order to confirm and close the unified Chrome consent dialog.
The status of the unified Chrome consent. This specifies whether the consent was given or not given/revoked.
Contains user profile information.
Used in:
Primary email address of the user.
The user's full name.
Portrait photo of the user.
Used in:
Time of event, as measured by client in microseconds since Windows epoch.
The |global_id| field of the associated navigation, if there is one.
On startup we generate a new random id to identify which FieldTrialEvents other events belonged to.
Happens when a user types their Google account password on another site.
Used in:
If not set, it means that the floc is disabled.
Event added because the floc id is computed for the 1st floc session.
Event added because the floc id is re-computed due to a long period of time has passed since the last computation.
Event added because the floc id is re-computed due to history deletion.
Logged when the user logs into Google, and at least once per 28d.
Used in:
Used in:
Event added because user logged in.
Event added because 28d timer fired.
Language detection output.
Used in:
Top n languages. Typically we just log the top language, but for page that we're not confident about, we may log up to 3 top languages in descending order.
Adopted language code is the code of final determined language. It will be stored only if it's different from the first detected language.
Used in:
ISO 639 language code will be used.
Whether the detected language is reliable, note this is determined by the CLD3.
Used for testing and debugging EventLog system.
Used in:
(message has no fields)
User translated a page or interacted with translate suggestion.
Used in:
Source language of the translation.
Target language of the translation.
Used in:
This happens when user scroll or click outside the UI without translation.
This happens when user choose to close the translation window without translation.
User manually entered either language. In this case, from_language_code and to_language_code will be user chosen values.
User choose to revert the translation, in this case, from_language_code and to_language_code will be previous chosen values.
Automatically triggered translation. User sets always translate in user settings.
User navigated through a click from a translated page.
Failed to initialize the translate script, this can happen for iOS due to CSPs.
Used in:
,Obfuscated Gaia ID.
Latest user's public key registered on the server.
Contains information about the cloud token data of server credit cards.
Used in:
Server-generated ID string for the card this cloud token data is related to. This should match the id in WalletMaskedCreditCard for to fetch the corresponding actual card data. Note this is not unique across all cloud token data, which means one card can have multiple sets of cloud token data with the same masked_card_id.
Last 4-5 digits of the Cloud Primary Account Number (CPAN).
CPAN Month number 1-12.
CPAN Four-digit year (e.g. 2017).
URL of the card art to be displayed for CPAN.
Opaque identifier for the cloud token.
Used in:
Server-generated unique ID string. This is opaque to the client. This is the legacy version of |instrument_id|.
What the server thinks of this card.
Last 4 digits of the credit card number.
Month number 1-12.
Four-digit year (e.g. 2017).
The WalletPostalAddress.id of the billing address.
Issuing Bank name which is internationalized (e.g. "Chase", "工商银行")
TODO(crbug.com/1020740): Deprecated, remove this once dependent change is done. Use WalletCreditCardCloudTokenData instead. This field will be set if a cloud token is available for the instrument.
The card's nickname, if it exists.
Issuer of the card.
Server-generated unique ID. This is opaque to the client. |id| is the legacy version of this.
The state of virtual card enrollment.
The URL for the client to fetch the card art image.
The product description for the card. Used to be shown in the UI.
The type of virtual card enrollment. kTypeUnspecified indicates that the card is unenrolled.
The benefits (e.g. points or discounts) associated with purchases made with the card.
Separate link from the card issuer which provides additional context or terms and conditions regarding the credit card product and its benefits.
Used in:
Used in:
Used in:
Used in:
Contains information of server IBAN (International Bank Account Number).
Used in:
,Opaque identifier for the account stored in Payments Platform.
Prefix of the full IBAN value, if available.
Suffix of the full IBAN value, if available.
Length of the full IBAN value, if available.
Nickname for the IBAN, if available.
Wallet card usage information that can be synced.
Used in:
The type of the Wallet metadata.
Base64 encoding of the unique ID string of the corresponding AutofillMetadata. For Wallet cards, this value is WalletMaskedCreditCard::id. For Wallet IBANs, this value is WalletMaskedIban::instrument_id.
The number of times that this Wallet card or address was used.
The last use date of this Wallet card or address. Measured in microseconds since the Windows epoch (1601).
The id of the profile/address that represents the billing address of this Wallet card.
Unused by the client since M121. TODO(crbug.com/1457187): Some server-side code still relies on this field. To keep the protos in sync, it is kept until that code is cleaned up.
Used in:
Unused by the client since M121. TODO(crbug.com/1457187): Some server-side code still relies on this. To keep the protos in sync, it is kept until that code is cleaned up.
Unused by the client since M121. TODO(crbug.com/1457187): Some server-side code still relies on this message. To keep the protos in sync, it is kept until that code is cleaned up. Different than an AutofillProfile because this represents some known address on the server that is pulled down rather than synced between Chromes.
Used in:
This is the street address, of which there may be multiple lines. This corresponds to "address_home_line[1|2] in the AutofillProfileSpecifics message above. In some locales there may be more than two lines.
Also known as "administrative area". This is normally the state or province in most countries.
Also known as "locality". In the US this is the city.
A sub-classification beneath the city, e.g. an inner-city district or suburb. Also known as "dependent_locality"
Used in certain countries. Also known as "sub_dependent_locality".
Similar to the zipcode column, but used for businesses or organizations that might not be geographically contiguous. The canonical example is CEDEX in France.
Phone number. The format is unspecified and will be explicitly ignored.
Flags for enabling wallet data syncing.
Used in:
Sync & local data: Information about web app icon.
Used in:
The size of the square app icon, in raw pixels.
The URL of the app icon.
The purpose or context in which the icon should be used.
Used in:
Suitable for any purpose.
Designed for masking.
Suitable for monochrome purposes.
WebApk data.
Used in:
Time when this WebApk was last used or installed. Number of microseconds since 1601, aka Windows epoch.
Sync & local data: Information about web app icon.
Used in:
The size of the square app icon, in raw pixels.
The URL of the app icon.
The purpose or context in which the icon should be used.
Used in:
Suitable for any purpose.
Designed for masking.
Suitable for monochrome purposes.
WebApp data. This is a synced part of chrome/browser/web_applications/proto/web_app.proto data.
Used in:
User-selected display setting, which may be used if no platform-specific setting is available (eg. on Windows, Mac, and Linux). If absent, user_display_mode_cros may be used as fallback (if populated). On pre-M122 devices this field is used by all platforms (ie. ChromeOS, Windows, Mac, Linux) and always replaces any locally-stored value, with absent/unspecified falling back to standalone.
Used to store the page number that the app is displayed on in chrome://apps.
Used to store the in-page ranking for ordering apps in its given |user_page_ordinal| page.
Used to store id specified in the manifest. This is a path that is relative to the start_url, similar to how the id field is parsed in https://www.w3.org/TR/appmanifest/#id-member, except this field does not include a scheme or origin. This is only the path after the origin, excluding the first "/". Note: If this field is not set, then the manifest_id is generated using the start_url in GenerateManifestIdFromStartUrlOnly. This is different than if this is set to "", which means the manifest_id will be set to the origin of the start_url.
User-selected display setting for ChromeOS. If absent, user_display_mode_default may be used as fallback (if populated). Introduced in M122.
This enum should be a subset of the DisplayMode enum in chrome/browser/web_applications/proto/web_app.proto and third_party/blink/public/mojom/manifest/display_mode.mojom
Used in:
MINIMAL_UI is never serialized.
FULLSCREEN is never serialized. WINDOW_CONTROLS_OVERLAY is never serialized.
BORDERLESS is never serialized. PICTURE_IN_PICTURE is never serialized.
WebauthnCredentialSpecifics is an entity that backs a WebAuthn PublicKeyCredential. Since it contains the authenticator’s view of this object, it has a private key rather than a public key. (https://www.w3.org/TR/webauthn-2/#iface-pkcredential). Names of fields are taken from WebAuthn where possible. E.g. user.displayName in WebAuthn becomes user_display_name here. All fields are immutable after creation except for user_name and user_display_name, which may be updated by a user.
Used in:
Sync's ID for this entity (sometimes called the client unique tag), 16 random bytes. This value is used within Sync to identify this entity. The credential ID is not used because the (hashed) sync_id is exposed to the Sync server, and we don’t want Google to be able to map a credential ID to an account. Password entities construct this value from the concatenation of many fields and depend on the fact that the server only sees a hash of it. But the only high-entropy secret here is the private key, which will have different encryption in the future, and private keys are not the sort of data to copy into other fields. Therefore this independent value is provided to form the client's ID.
The credential ID, 16 random bytes. This is a value surfaced in the WebAuthn API (https://www.w3.org/TR/webauthn-2/#credential-id).
An RP ID is a WebAuthn concept: https://www.w3.org/TR/webauthn-2/#rp-id. It’s usually a domain name, although in non-Web contexts it can be a URL with a non-Web scheme.
The user ID, which is also called a “user handle” in WebAuthn (https://www.w3.org/TR/webauthn-2/#user-handle), is an RP-specific identifier that is up to 64-bytes long. An authenticator conceptually only stores a single credential for a given (rp_id, user_id) pair, but there may be several credentials in Sync. They are prioritised using newly_shadowed_credential_ids and creation_time. See below. (We wish to be able to retain several entities for a single (rp_id, user_id) pair because there’s an edge case where we may wish to revert to an older entry and thus need to keep the older entry around in Sync. The revert could happen on a different device too.)
The id of credentials with the same (rp_id, user_id) that were shadowed by the creation of this entity. A credential is shadowed if one or more other credentials (from the same account, and with the same (rp_id, user_id)) include its credential_id in their list of shadowed IDs. Shadowed credentials are ignored when finding a credential to sign with. If there is more than one candidate remaining after filtering shadowed credentials then the most recently created (based on creation_time) is used. The reason for all this is that sites can replace a credential by creating another one with the same (rp_id, user_id) pair. However, we don't immediately know whether the WebAuthn response reached the website's server. Consider a user with a poor internet connection. Javascript in the site's origin triggers a credential creation that “overwrites” an existing credential, but the Javascript is unable to send the new public key to the website's server. The user is now locked out: the old credential has been over-written but the website's server doesn't know about the new one. Thus we wish to keep “overwritten” credentials around for a while to allow for some sort of recovery. In the simple case, a new credential shadows the single, previous old credential. We could depend on creation_time, but client clocks aren't always accurate, thus this field. In complicated cases two devices might race to replace a credential, in which case (after mutual syncing) two candidate credentials exist for the same (rp_id, user_id) pair because neither shadows the other. In this case we pick the newest based on |creation_time| but it's quite possible that some recovery will be needed because the website's server thinks the other one is correct. A generation counter isn't used because a single device might replace a series of credentials as it tries to update the website's server. But that doesn't mean that it should dominate a different device that replaced it only once, but later.
The local time on the device when this credential was created. Given in milliseconds since the UNIX epoch. This is used to break ties between credentials. See newly_shadowed_credential_ids.
The human-readable account identifier. Usually an email address. This is mutable. https://www.w3.org/TR/webauthn-2/#dom-publickeycredentialentity-name
The human-readable name. Usually a legal name. This is mutable. https://www.w3.org/TR/webauthn-2/#dom-publickeycredentialuserentity-displayname.
Credentials may optionally be enabled for Secure Payment Confirmation[1] on third-party sites. This is opt-in at creation time. [1] https://www.w3.org/TR/secure-payment-confirmation/
Time when this passkey was last successfully asserted. Number of microseconds since 1601, aka Windows epoch. This mirrors the `date_last_used` field in PasswordSpecificsData.
The "version" (sometimes called the epoch) of the key that `encrypted_data` is encrypted with. This allows trial decryption to be avoided when present.
The bytes of the private key, encrypted with a feature-specific security domain.
A serialized, `Encrypted` message, encrypted with a feature-specific security domain.
The bytes of the private key, in PKCS#8 format.
The secret for implementing the hmac-secret extension https://fidoalliance.org/specs/fido-v2.1-ps-20210615/fido-client-to-authenticator-protocol-v2.1-ps-errata-20220621.html#sctn-hmac-secret-extension
The contents of the credential's credBlob. https://fidoalliance.org/specs/fido-v2.1-ps-20210615/fido-client-to-authenticator-protocol-v2.1-ps-errata-20220621.html#sctn-credBlob-extension
The contents of the credential's largeBlob value(*). Unlike with security keys, largeBlob data is not stored in a single lump for all credentials, but as per-credential data. This data is presented to the authenticator over CTAP and thus has already had the required DEFLATE compression applied by the remote platform. The uncompressed size of this data is in the next field. (*) "large" with respect to embedded devices. Maximum length is 2KiB for Google Password Manager. https://fidoalliance.org/specs/fido-v2.1-ps-20210615/fido-client-to-authenticator-protocol-v2.1-ps-errata-20220621.html#authenticatorLargeBlobs
The claimed uncompressed size of the DEFLATE-compressed data in `large_blob`. This corresponds to the `origSize` field from the spec: https://fidoalliance.org/specs/fido-v2.1-ps-20210615/fido-client-to-authenticator-protocol-v2.1-ps-errata-20220621.html#large-blob
Used in:
SSID encoded to hex, letters should be upper case and 0x prefix should be omitted. For example, ssid "network" would be provided as "6E6574776F726B".
The passphrase can be ASCII, UTF-8, or a string of hex digits.
List of DNS servers to be used when set to DNS_OPTION_CUSTOM. Up to 4.
The last time this configuration was connected to before being synced. It will only be updated when the configuration is changed. This is represented with the UNIX timestamp, ms since epoch.
Used in:
Used in:
Used in:
Used in:
Allows the device to use heuristics to determine if network is metered.
Used in:
Only set if PROXY_OPTION_AUTOMATIC.
Only set if PROXY_OPTION_MANUAL.
Used in:
Used in:
Use a Proxy Auto-config(PAC) Url, set in proxy_url
Uses Web Proxy Auto-Discovery Protocol (WPAD) to discover the proxy settings using DHCP/DNS.
User sets details in manual_proxy_configuration.
Used in:
WPA-PSK or RSN-PSK
A workspace desk entry. This proto contains the fields synced to represent a saved desk in user's workspace.
Used in:
A random unique identifier for each desk. Required.
The name of the desk being saved.
The time this snapshot of desk was created.
The time this snapshot of desk was updated.
The type of a desk.
The cache guid of the syncing client. Used to identify a unique device that's syncing data.
The form factor of the device.
A Launchable app in template.
Used in:
The on-display location of this window.
The z-index of this app relative to other apps in this template. App with larger z-index appears in front of app with smaller z-index.
window_id used to instantiate proto as a restore_data object. The restore_data object in question can be found at: //components/app_restore/restore_data.h
Display ID this app is on.
State of a window before it was minimized. Empty/unset for non-minimized windows.
Container this app was launched from. Empty/unset for Arc apps.
Window open disposition, defines how a window opens. Empty/unset for Arc apps.
Name of the app which is used by the browser to determine whether to launch an app as an app or a tab. Does not contain a human readable name but contains the app ID and a prefix.
Human readable title of the app.
This is used to determine the size of a snapped window is in clamshell mode. Empty/unset for non-snapped windows. This should be a value between 0 and 100.
The override URL can be specified by apps to override the default URL at launch.
Used in:
An Arc App window.
Used in:
The Arc App's ID.
Arc window information. This maps to ArcExtraInfo in a WindowInfo struct.
maps to gfx::Size. Width of the window, including the frame, in pixels.
Used in:
A Chrome or Lacros Browser app window.
Used in:
The tabs in this browser window.
The index of the currently active tab.
Indicates whether to show as a dedicated app window.
Tab groups associated with this window.
The index of the first non-pinned tab.
Used in:
The last committed URL of the main frame of the tab.
The title of the tab.
Structure representing a tab group associated with this window.
Used in:
Zero-based index within the browser app tabs of the first tab in the group.
Zero-based Index wotjom the browser app tabs of the last tab in the group.
User readable title of the tab group.
Color associated with this tab group.
Indicates whether the tab group is collapsed.
A Chrome App window.
Used in:
The Chrome App's App ID.
Represent a snapshot of the information on a desk.
Used in:
The apps in this template.
Enumerates the type of desk, namely to differentiate desks between desks saved for desk templates and desks saved for save and recall.
Used in:
Enumeration for the container an app was launched from as used by (components/services/app_services/public/mojom/types.mojom:490).
Used in:
A PWA window.
Used in:
The PWA's App ID.
Enumerates the possible colors that a tab group can have. This mirrors the enumeration that can be found in components/tab_groups/tab_group_color.h
Used in:
Used in:
,The offset of the window from the top edge of the screen in pixels.
The offset of the window from the left edge of the screen in pixels.
The width of the window, including the frame, in pixels.
The height of the window, including the frame, in pixels.
Enumeration for how a window opens. Maps to base::WindowOpenDisposition. (found in ui/base/window_open_disposition.h:10). Does not include MAX_VALUE as MAX_VALUE is equivalent to NEW_PICTURE_IN_PICTURE. All comments are copied verbatim from aforementioned header.
Used in:
Indicates that only one tab with the URL shoul exist in the same window.
Activates an existing tab containing the URL, rather than navigating. This is similar to SINGLETON_TAB, but searches across all windows from the current profile and anymity (instead of tjust the current one); closes the current tab on switching if the current ta was the NTP with no session history; and behaves like CURRENT_TAB instead of NEW_FOREGROUND_TAB when no existing tab is found.
creates a new document picture-in-picture window showing a child WebView.
The state of a generic window.
Used in:
Normal window state (not minimized, maximized, or fullscreen).
Minimized window state.
Maximized window state.
Fullscreen window state.
Snapped to primary half of the screen. Primary half is on the left in landscape screen orientation and top in portrait screen orientation.
Snapped to secondary half of the screen. Secondary half is on the right in landscape screen orientation and bottom in portrait screen orientation.
Floated window state.