sync: remove use of protobuf extensions in protocol to reduce static init overhead.

net/tools/testserver/chromiumsync.py

 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """An implementation of the server side of the Chromium sync protocol.
 
 The details of the protocol are described mostly by comments in the protocol
 buffer definition at chrome/browser/sync/protocol/sync.proto.
 """
 
@@ skipping 19 matching lines @@
 import preference_specifics_pb2
 import search_engine_specifics_pb2
 import session_specifics_pb2
 import sync_pb2
 import sync_enums_pb2
 import theme_specifics_pb2
 import typed_url_specifics_pb2
 
 # An enumeration of the various kinds of data that can be synced.
 # Over the wire, this enumeration is not used: a sync object's type is
-# inferred by which EntitySpecifics extension it has.  But in the context
+# inferred by which EntitySpecifics field it has.  But in the context
 # of a program, it is useful to have an enumeration.
 ALL_TYPES = (
     TOP_LEVEL,  # The type of the 'Google Chrome' folder.
     APPS,
     APP_NOTIFICATION,
     APP_SETTINGS,
     AUTOFILL,
     AUTOFILL_PROFILE,
     BOOKMARK,
     EXTENSIONS,
@@ skipping 10 matching lines @@
 # to the client. This would be specified by the url that triggers the error.
 # Note: This enum should be kept in the same order as the enum in sync_test.h.
 SYNC_ERROR_FREQUENCY = (
     ERROR_FREQUENCY_NONE,
     ERROR_FREQUENCY_ALWAYS,
     ERROR_FREQUENCY_TWO_THIRDS) = range(3)
 
 # Well-known server tag of the top level 'Google Chrome' folder.
 TOP_LEVEL_FOLDER_TAG = 'google_chrome'
 
-# Given a sync type from ALL_TYPES, find the extension token corresponding
+# Given a sync type from ALL_TYPES, find the FieldDescriptor corresponding
 # to that datatype.  Note that TOP_LEVEL has no such token.
-SYNC_TYPE_TO_EXTENSION = {
-    APP_NOTIFICATION: app_notification_specifics_pb2.app_notification,
-    APP_SETTINGS: app_setting_specifics_pb2.app_setting,
-    APPS: app_specifics_pb2.app,
-    AUTOFILL: autofill_specifics_pb2.autofill,
-    AUTOFILL_PROFILE: autofill_specifics_pb2.autofill_profile,
-    BOOKMARK: bookmark_specifics_pb2.bookmark,
-    EXTENSION_SETTINGS: extension_setting_specifics_pb2.extension_setting,
-    EXTENSIONS: extension_specifics_pb2.extension,
-    NIGORI: nigori_specifics_pb2.nigori,
-    PASSWORD: password_specifics_pb2.password,
-    PREFERENCE: preference_specifics_pb2.preference,
-    SEARCH_ENGINE: search_engine_specifics_pb2.search_engine,
-    SESSION: session_specifics_pb2.session,
-    THEME: theme_specifics_pb2.theme,
-    TYPED_URL: typed_url_specifics_pb2.typed_url,
+SYNC_TYPE_FIELDS = sync_pb2.EntitySpecifics.DESCRIPTOR.fields_by_name
+SYNC_TYPE_TO_DESCRIPTOR = {
+    APP_NOTIFICATION: SYNC_TYPE_FIELDS['app_notification'],
+    APP_SETTINGS: SYNC_TYPE_FIELDS['app_setting'],
+    APPS: SYNC_TYPE_FIELDS['app'],
+    AUTOFILL: SYNC_TYPE_FIELDS['autofill'],
+    AUTOFILL_PROFILE: SYNC_TYPE_FIELDS['autofill_profile'],
+    BOOKMARK: SYNC_TYPE_FIELDS['bookmark'],
+    EXTENSION_SETTINGS: SYNC_TYPE_FIELDS['extension_setting'],
+    EXTENSIONS: SYNC_TYPE_FIELDS['extension'],
+    NIGORI: SYNC_TYPE_FIELDS['nigori'],
+    PASSWORD: SYNC_TYPE_FIELDS['password'],
+    PREFERENCE: SYNC_TYPE_FIELDS['preference'],
+    SEARCH_ENGINE: SYNC_TYPE_FIELDS['search_engine'],
+    SESSION: SYNC_TYPE_FIELDS['session'],
+    THEME: SYNC_TYPE_FIELDS['theme'],
+    TYPED_URL: SYNC_TYPE_FIELDS['typed_url'],
     }
 
 # The parent ID used to indicate a top-level node.
 ROOT_ID = '0'
 
 # Unix time epoch in struct_time format. The tuple corresponds to UTC Wednesday
 # Jan 1 1970, 00:00:00, non-dst.
 UNIX_TIME_EPOCH = (1970, 1, 1, 0, 0, 0, 3, 1, 0)
 
 class Error(Exception):
   """Error class for this module."""
 
 
-class ProtobufExtensionNotUnique(Error):
-  """An entry should not have more than one protobuf extension present."""
+class ProtobufDataTypeFieldNotUnique(Error):
+  """An entry should not have more than one data type present."""
 
 
 class DataTypeIdNotRecognized(Error):
   """The requested data type is not recognized."""
 
 
 class MigrationDoneError(Error):
   """A server-side migration occurred; clients must re-sync some datatypes.
 
   Attributes:
@@ skipping 22 matching lines @@
 
 def GetEntryType(entry):
   """Extract the sync type from a SyncEntry.
 
   Args:
     entry: A SyncEntity protobuf object whose type to determine.
   Returns:
     An enum value from ALL_TYPES if the entry's type can be determined, or None
     if the type cannot be determined.
   Raises:
-    ProtobufExtensionNotUnique: More than one type was indicated by the entry.
+    ProtobufDataTypeFieldNotUnique: More than one type was indicated by
+    the entry.
   """
   if entry.server_defined_unique_tag == TOP_LEVEL_FOLDER_TAG:
     return TOP_LEVEL
   entry_types = GetEntryTypesFromSpecifics(entry.specifics)
   if not entry_types:
     return None
 
   # If there is more than one, either there's a bug, or else the caller
   # should use GetEntryTypes.
   if len(entry_types) > 1:
-    raise ProtobufExtensionNotUnique
+    raise ProtobufDataTypeFieldNotUnique
   return entry_types[0]
 
 
 def GetEntryTypesFromSpecifics(specifics):
-  """Determine the sync types indicated by an EntitySpecifics's extension(s).
+  """Determine the sync types indicated by an EntitySpecifics's field(s).
 
-  If the specifics have more than one recognized extension (as commonly
+  If the specifics have more than one recognized data type field (as commonly
   happens with the requested_types field of GetUpdatesMessage), all types
   will be returned.  Callers must handle the possibility of the returned
   value having more than one item.
 
   Args:
     specifics: A EntitySpecifics protobuf message whose extensions to
       enumerate.
   Returns:
     A list of the sync types (values from ALL_TYPES) associated with each
     recognized extension of the specifics message.
   """
-  return [data_type for data_type, extension
-          in SYNC_TYPE_TO_EXTENSION.iteritems()
-          if specifics.HasExtension(extension)]
+  return [data_type for data_type, field_descriptor
+          in SYNC_TYPE_TO_DESCRIPTOR.iteritems()
+          if specifics.HasField(field_descriptor.name)]
 
 
 def SyncTypeToProtocolDataTypeId(data_type):
   """Convert from a sync type (python enum) to the protocol's data type id."""
-  return SYNC_TYPE_TO_EXTENSION[data_type].number
+  return SYNC_TYPE_TO_DESCRIPTOR[data_type].number
 
 
 def ProtocolDataTypeIdToSyncType(protocol_data_type_id):
   """Convert from the protocol's data type id to a sync type (python enum)."""
-  for data_type, protocol_extension in SYNC_TYPE_TO_EXTENSION.iteritems():
-    if protocol_extension.number == protocol_data_type_id:
+  for data_type, field_descriptor in SYNC_TYPE_TO_DESCRIPTOR.iteritems():
+    if field_descriptor.number == protocol_data_type_id:
       return data_type
   raise DataTypeIdNotRecognized
 
 
 def DataTypeStringToSyncTypeLoose(data_type_string):
   """Converts a human-readable string to a sync type (python enum).
 
   Capitalization and pluralization don't matter; this function is appropriate
   for values that might have been typed by a human being; e.g., command-line
   flags or query parameters.
   """
   if data_type_string.isdigit():
     return ProtocolDataTypeIdToSyncType(int(data_type_string))
   name = data_type_string.lower().rstrip('s')
-  for data_type, protocol_extension in SYNC_TYPE_TO_EXTENSION.iteritems():
-    if protocol_extension.name.lower().rstrip('s') == name:
+  for data_type, field_descriptor in SYNC_TYPE_TO_DESCRIPTOR.iteritems():
+    if field_descriptor.name.lower().rstrip('s') == name:
       return data_type
   raise DataTypeIdNotRecognized
 
 
 def SyncTypeToString(data_type):
   """Formats a sync type enum (from ALL_TYPES) to a human-readable string."""
-  return SYNC_TYPE_TO_EXTENSION[data_type].name
+  return SYNC_TYPE_TO_DESCRIPTOR[data_type].name
 
 
 def CallerInfoToString(caller_info_source):
   """Formats a GetUpdatesSource enum value to a readable string."""
   return sync_pb2.GetUpdatesCallerInfo.DESCRIPTOR.enum_types_by_name[
       'GetUpdatesSource'].values_by_number[caller_info_source].name
 
 
 def ShortDatatypeListSummary(data_types):
   """Formats compactly a list of sync types (python enums) for human eyes.
@@ skipping 11 matching lines @@
   simple_text = '+'.join(sorted([SyncTypeToString(x) for x in included]))
   all_but_text = 'all except %s' % (
       '+'.join(sorted([SyncTypeToString(x) for x in excluded])))
   if len(included) < len(excluded) or len(simple_text) <= len(all_but_text):
     return simple_text
   else:
     return all_but_text
 
 
 def GetDefaultEntitySpecifics(data_type):
-  """Get an EntitySpecifics having a sync type's default extension value."""
+  """Get an EntitySpecifics having a sync type's default field value."""
   specifics = sync_pb2.EntitySpecifics()
-  if data_type in SYNC_TYPE_TO_EXTENSION:
-    extension_handle = SYNC_TYPE_TO_EXTENSION[data_type]
-    specifics.Extensions[extension_handle].SetInParent()
+  if data_type in SYNC_TYPE_TO_DESCRIPTOR:
+    descriptor = SYNC_TYPE_TO_DESCRIPTOR[data_type]
+    getattr(specifics, descriptor.name).SetInParent()
   return specifics
 
 
 class PermanentItem(object):
   """A specification of one server-created permanent item.
 
   Attributes:
     tag: A known-to-the-client value that uniquely identifies a server-created
       permanent item.
     name: The human-readable display name for this item.
@@ skipping 214 matching lines @@
     entry.sync_timestamp = self._version
 
     # Preserve the originator info, which the client is not required to send
     # when updating.
     base_entry = self._entries.get(entry.id_string)
     if base_entry:
       entry.originator_cache_guid = base_entry.originator_cache_guid
       entry.originator_client_item_id = base_entry.originator_client_item_id
 
     self._entries[entry.id_string] = copy.deepcopy(entry)
-    # Store the current time since the Unix epoch in milliseconds.
-    self._entries[entry.id_string].mtime = (int((time.mktime(time.gmtime()) -
-        time.mktime(UNIX_TIME_EPOCH))*1000))
 
   def _ServerTagToId(self, tag):
     """Determine the server ID from a server-unique tag.
 
     The resulting value is guaranteed not to collide with the other ID
     generation methods.
 
     Args:
       datatype: The sync type (python enum) of the identified object.
       tag: The unique, known-to-the-client tag of a server-generated item.
@@ skipping 375 matching lines @@
       # we ignore insert_after_item_id (an older style).
       self._WritePosition(entry, entry.parent_id_string)
 
     # Preserve the originator info, which the client is not required to send
     # when updating.
     base_entry = self._entries.get(entry.id_string)
     if base_entry and not entry.HasField('originator_cache_guid'):
       entry.originator_cache_guid = base_entry.originator_cache_guid
       entry.originator_client_item_id = base_entry.originator_client_item_id
 
+    # Store the current time since the Unix epoch in milliseconds.
+    entry.mtime = (int((time.mktime(time.gmtime()) -
+        time.mktime(UNIX_TIME_EPOCH))*1000))
+
     # Commit the change.  This also updates the version number.
     self._SaveEntry(entry)
     return entry
 
   def _RewriteVersionInId(self, id_string):
     """Rewrites an ID so that its migration version becomes current."""
     parsed_id = self._ExtractIdInfo(id_string)
     if not parsed_id:
       return id_string
     datatype, old_migration_version, inner_id = parsed_id
@@ skipping 18 matching lines @@
 
   def TriggerSyncTabs(self):
     """Set the 'sync_tabs' field to this account's nigori node.
 
     If the field is not currently set, will write a new nigori node entry
     with the field set. Else does nothing.
     """
 
     nigori_tag = "google_chrome_nigori"
     nigori_original = self._entries.get(self._ServerTagToId(nigori_tag))
-    if (nigori_original.specifics.Extensions[nigori_specifics_pb2.nigori].
-        sync_tabs):
+    if (nigori_original.specifics.nigori.sync_tabs):
       return
     nigori_new = copy.deepcopy(nigori_original)
-    nigori_new.specifics.Extensions[nigori_specifics_pb2.nigori].sync_tabs = (
-        True)
+    nigori_new.specifics.nigori.sync_tabs = True
     self._SaveEntry(nigori_new)
 
   def SetInducedError(self, error, error_frequency,
                       sync_count_before_errors):
     self.induced_error = error
     self.induced_error_frequency = error_frequency
     self.sync_count_before_errors = sync_count_before_errors
 
   def GetInducedError(self):
     return self.induced_error
@@ skipping 290 matching lines @@
 
     update_sieve.CheckMigrationState()
 
     new_timestamp, entries, remaining = self.account.GetChanges(update_sieve)
 
     update_response.changes_remaining = remaining
     for entry in entries:
       reply = update_response.entries.add()
       reply.CopyFrom(entry)
     update_sieve.SaveProgress(new_timestamp, update_response)