Move //mojo/{public, edk} underneath //third_party

This CL move //mojo/public and //mojo/edk to live in the following locations:
- //third_party/mojo/src/mojo/public
- //third_party/mojo/src/mojo/edk

It moves the related gypfiles from //mojo to //third_party/mojo and updates
them as necessary to account for the file moves. It also updates clients of the
mojo SDK and EDK targets in both GYP and GN. (Note that for GN, the mojo SDK
and EDK build systems are maintained in the Mojo repo and designed to be
flexible wrt the location of the SDK/EDK in a client repo, so no changes are
needed.

This CL does not update include paths to the code being moved to limit the
number of moving parts, instead relying on the include_dirs that the SDK and
EDK targets supply to their direct dependents to ensure that include paths
continue to resolve correctly.

NOPRESUBMIT=true

Review URL: https://codereview.chromium.org/814543006

Cr-Commit-Position: refs/heads/master@{#312129}

1 files changed, 0 insertions, 420 deletions

diff --git a/mojo/public/tools/bindings/pylib/mojom/generate/data.py b/mojo/public/tools/bindings/pylib/mojom/generate/data.py
deleted file mode 100644
index 6d34a40..0000000
--- a/mojo/public/tools/bindings/pylib/mojom/generate/data.py
+++ /dev/null
@@ -1,420 +0,0 @@
-# Copyright 2013 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.
-
-# TODO(vtl): "data" is a pretty vague name. Rename it?
-
-import copy
-
-import module as mojom
-
-# This module provides a mechanism to turn mojom Modules to dictionaries and
-# back again. This can be used to persist a mojom Module created progromatically
-# or to read a dictionary from code or a file.
-# Example:
-# test_dict = {
-#   'name': 'test',
-#   'namespace': 'testspace',
-#   'structs': [{
-#     'name': 'teststruct',
-#     'fields': [
-#       {'name': 'testfield1', 'kind': 'i32'},
-#       {'name': 'testfield2', 'kind': 'a:i32', 'ordinal': 42}]}],
-#   'interfaces': [{
-#     'name': 'Server',
-#     'methods': [{
-#       'name': 'Foo',
-#       'parameters': [{
-#         'name': 'foo', 'kind': 'i32'},
-#         {'name': 'bar', 'kind': 'a:x:teststruct'}],
-#     'ordinal': 42}]}]
-# }
-# test_module = data.ModuleFromData(test_dict)
-
-# Used to create a subclass of str that supports sorting by index, to make
-# pretty printing maintain the order.
-def istr(index, string):
-  class IndexedString(str):
-    def __lt__(self, other):
-      return self.__index__ < other.__index__
-
-  rv = IndexedString(string)
-  rv.__index__ = index
-  return rv
-
-builtin_values = frozenset([
-    "double.INFINITY",
-    "double.NEGATIVE_INFINITY",
-    "double.NAN",
-    "float.INFINITY",
-    "float.NEGATIVE_INFINITY",
-    "float.NAN"])
-
-def IsBuiltinValue(value):
-  return value in builtin_values
-
-def LookupKind(kinds, spec, scope):
-  """Tries to find which Kind a spec refers to, given the scope in which its
-  referenced. Starts checking from the narrowest scope to most general. For
-  example, given a struct field like
-    Foo.Bar x;
-  Foo.Bar could refer to the type 'Bar' in the 'Foo' namespace, or an inner
-  type 'Bar' in the struct 'Foo' in the current namespace.
-
-  |scope| is a tuple that looks like (namespace, struct/interface), referring
-  to the location where the type is referenced."""
-  if spec.startswith('x:'):
-    name = spec[2:]
-    for i in xrange(len(scope), -1, -1):
-      test_spec = 'x:'
-      if i > 0:
-        test_spec += '.'.join(scope[:i]) + '.'
-      test_spec += name
-      kind = kinds.get(test_spec)
-      if kind:
-        return kind
-
-  return kinds.get(spec)
-
-def LookupValue(values, name, scope, kind):
-  """Like LookupKind, but for constant values."""
-  # If the type is an enum, the value can be specified as a qualified name, in
-  # which case the form EnumName.ENUM_VALUE must be used. We use the presence
-  # of a '.' in the requested name to identify this. Otherwise, we prepend the
-  # enum name.
-  if isinstance(kind, mojom.Enum) and '.' not in name:
-    name = '%s.%s' % (kind.spec.split(':', 1)[1], name)
-  for i in reversed(xrange(len(scope) + 1)):
-    test_spec = '.'.join(scope[:i])
-    if test_spec:
-      test_spec += '.'
-    test_spec += name
-    value = values.get(test_spec)
-    if value:
-      return value
-
-  return values.get(name)
-
-def FixupExpression(module, value, scope, kind):
-  """Translates an IDENTIFIER into a built-in value or structured NamedValue
-     object."""
-  if isinstance(value, tuple) and value[0] == 'IDENTIFIER':
-    # Allow user defined values to shadow builtins.
-    result = LookupValue(module.values, value[1], scope, kind)
-    if result:
-      if isinstance(result, tuple):
-        raise Exception('Unable to resolve expression: %r' % value[1])
-      return result
-    if IsBuiltinValue(value[1]):
-      return mojom.BuiltinValue(value[1])
-  return value
-
-def KindToData(kind):
-  return kind.spec
-
-def KindFromData(kinds, data, scope):
-  kind = LookupKind(kinds, data, scope)
-  if kind:
-    return kind
-
-  if data.startswith('?'):
-    kind = KindFromData(kinds, data[1:], scope).MakeNullableKind()
-  elif data.startswith('a:'):
-    kind = mojom.Array(KindFromData(kinds, data[2:], scope))
-  elif data.startswith('a'):
-    colon = data.find(':')
-    length = int(data[1:colon])
-    kind = mojom.Array(KindFromData(kinds, data[colon+1:], scope), length)
-  elif data.startswith('r:'):
-    kind = mojom.InterfaceRequest(KindFromData(kinds, data[2:], scope))
-  elif data.startswith('m['):
-    # Isolate the two types from their brackets.
-
-    # It is not allowed to use map as key, so there shouldn't be nested ']'s
-    # inside the key type spec.
-    key_end = data.find(']')
-    assert key_end != -1 and key_end < len(data) - 1
-    assert data[key_end+1] == '[' and data[-1] == ']'
-
-    first_kind = data[2:key_end]
-    second_kind = data[key_end+2:-1]
-
-    kind = mojom.Map(KindFromData(kinds, first_kind, scope),
-                     KindFromData(kinds, second_kind, scope))
-  else:
-    kind = mojom.Kind(data)
-
-  kinds[data] = kind
-  return kind
-
-def KindFromImport(original_kind, imported_from):
-  """Used with 'import module' - clones the kind imported from the given
-  module's namespace. Only used with Structs, Unions, Interfaces and Enums."""
-  kind = copy.copy(original_kind)
-  # |shared_definition| is used to store various properties (see
-  # |AddSharedProperty()| in module.py), including |imported_from|. We don't
-  # want the copy to share these with the original, so copy it if necessary.
-  if hasattr(original_kind, 'shared_definition'):
-    kind.shared_definition = copy.copy(original_kind.shared_definition)
-  kind.imported_from = imported_from
-  return kind
-
-def ImportFromData(module, data):
-  import_module = data['module']
-
-  import_item = {}
-  import_item['module_name'] = import_module.name
-  import_item['namespace'] = import_module.namespace
-  import_item['module'] = import_module
-
-  # Copy the struct kinds from our imports into the current module.
-  importable_kinds = (mojom.Struct, mojom.Union, mojom.Enum, mojom.Interface)
-  for kind in import_module.kinds.itervalues():
-    if (isinstance(kind, importable_kinds) and
-        kind.imported_from is None):
-      kind = KindFromImport(kind, import_item)
-      module.kinds[kind.spec] = kind
-  # Ditto for values.
-  for value in import_module.values.itervalues():
-    if value.imported_from is None:
-      # Values don't have shared definitions (since they're not nullable), so no
-      # need to do anything special.
-      value = copy.copy(value)
-      value.imported_from = import_item
-      module.values[value.GetSpec()] = value
-
-  return import_item
-
-def StructToData(struct):
-  return {
-    istr(0, 'name'): struct.name,
-    istr(1, 'fields'): map(FieldToData, struct.fields)
-  }
-
-def StructFromData(module, data):
-  struct = mojom.Struct(module=module)
-  struct.name = data['name']
-  struct.attributes = data['attributes']
-  struct.spec = 'x:' + module.namespace + '.' + struct.name
-  module.kinds[struct.spec] = struct
-  struct.enums = map(lambda enum:
-      EnumFromData(module, enum, struct), data['enums'])
-  struct.constants = map(lambda constant:
-      ConstantFromData(module, constant, struct), data['constants'])
-  # Stash fields data here temporarily.
-  struct.fields_data = data['fields']
-  return struct
-
-def UnionToData(union):
-  return {
-    istr(0, 'name'): union.name,
-    istr(1, 'fields'): map(FieldToData, union.fields)
-  }
-
-def UnionFromData(module, data):
-  union = mojom.Union(module=module)
-  union.name = data['name']
-  union.spec = 'x:' + module.namespace + '.' + union.name
-  module.kinds[union.spec] = union
-  # Stash fields data here temporarily.
-  union.fields_data = data['fields']
-  return union
-
-def FieldToData(field):
-  data = {
-    istr(0, 'name'): field.name,
-    istr(1, 'kind'): KindToData(field.kind)
-  }
-  if field.ordinal != None:
-    data[istr(2, 'ordinal')] = field.ordinal
-  if field.default != None:
-    data[istr(3, 'default')] = field.default
-  return data
-
-def FieldFromData(module, data, struct):
-  field = mojom.Field()
-  field.name = data['name']
-  field.kind = KindFromData(
-      module.kinds, data['kind'], (module.namespace, struct.name))
-  field.ordinal = data.get('ordinal')
-  field.default = FixupExpression(
-      module, data.get('default'), (module.namespace, struct.name), field.kind)
-  return field
-
-def ParameterToData(parameter):
-  data = {
-    istr(0, 'name'): parameter.name,
-    istr(1, 'kind'): parameter.kind.spec
-  }
-  if parameter.ordinal != None:
-    data[istr(2, 'ordinal')] = parameter.ordinal
-  if parameter.default != None:
-    data[istr(3, 'default')] = parameter.default
-  return data
-
-def ParameterFromData(module, data, interface):
-  parameter = mojom.Parameter()
-  parameter.name = data['name']
-  parameter.kind = KindFromData(
-      module.kinds, data['kind'], (module.namespace, interface.name))
-  parameter.ordinal = data.get('ordinal')
-  parameter.default = data.get('default')
-  return parameter
-
-def MethodToData(method):
-  data = {
-    istr(0, 'name'):       method.name,
-    istr(1, 'parameters'): map(ParameterToData, method.parameters)
-  }
-  if method.ordinal != None:
-    data[istr(2, 'ordinal')] = method.ordinal
-  if method.response_parameters != None:
-    data[istr(3, 'response_parameters')] = map(
-        ParameterToData, method.response_parameters)
-  return data
-
-def MethodFromData(module, data, interface):
-  method = mojom.Method(interface, data['name'], ordinal=data.get('ordinal'))
-  method.default = data.get('default')
-  method.parameters = map(lambda parameter:
-      ParameterFromData(module, parameter, interface), data['parameters'])
-  if data.has_key('response_parameters'):
-    method.response_parameters = map(
-        lambda parameter: ParameterFromData(module, parameter, interface),
-                          data['response_parameters'])
-  return method
-
-def InterfaceToData(interface):
-  return {
-    istr(0, 'name'):    interface.name,
-    istr(1, 'client'):  interface.client,
-    istr(2, 'methods'): map(MethodToData, interface.methods)
-  }
-
-def InterfaceFromData(module, data):
-  interface = mojom.Interface(module=module)
-  interface.name = data['name']
-  interface.spec = 'x:' + module.namespace + '.' + interface.name
-  interface.client = data['client'] if data.has_key('client') else None
-  module.kinds[interface.spec] = interface
-  interface.enums = map(lambda enum:
-      EnumFromData(module, enum, interface), data['enums'])
-  interface.constants = map(lambda constant:
-      ConstantFromData(module, constant, interface), data['constants'])
-  # Stash methods data here temporarily.
-  interface.methods_data = data['methods']
-  return interface
-
-def EnumFieldFromData(module, enum, data, parent_kind):
-  field = mojom.EnumField()
-  field.name = data['name']
-  # TODO(mpcomplete): FixupExpression should be done in the second pass,
-  # so constants and enums can refer to each other.
-  # TODO(mpcomplete): But then, what if constants are initialized to an enum? Or
-  # vice versa?
-  if parent_kind:
-    field.value = FixupExpression(
-        module, data['value'], (module.namespace, parent_kind.name), enum)
-  else:
-    field.value = FixupExpression(
-        module, data['value'], (module.namespace, ), enum)
-  value = mojom.EnumValue(module, enum, field)
-  module.values[value.GetSpec()] = value
-  return field
-
-def EnumFromData(module, data, parent_kind):
-  enum = mojom.Enum(module=module)
-  enum.name = data['name']
-  name = enum.name
-  if parent_kind:
-    name = parent_kind.name + '.' + name
-  enum.spec = 'x:%s.%s' % (module.namespace, name)
-  enum.parent_kind = parent_kind
-
-  enum.fields = map(
-      lambda field: EnumFieldFromData(module, enum, field, parent_kind),
-      data['fields'])
-  module.kinds[enum.spec] = enum
-  return enum
-
-def ConstantFromData(module, data, parent_kind):
-  constant = mojom.Constant()
-  constant.name = data['name']
-  if parent_kind:
-    scope = (module.namespace, parent_kind.name)
-  else:
-    scope = (module.namespace, )
-  # TODO(mpcomplete): maybe we should only support POD kinds.
-  constant.kind = KindFromData(module.kinds, data['kind'], scope)
-  constant.value = FixupExpression(module, data.get('value'), scope, None)
-
-  value = mojom.ConstantValue(module, parent_kind, constant)
-  module.values[value.GetSpec()] = value
-  return constant
-
-def ModuleToData(module):
-  return {
-    istr(0, 'name'):       module.name,
-    istr(1, 'namespace'):  module.namespace,
-    istr(2, 'structs'):    map(StructToData, module.structs),
-    istr(3, 'interfaces'): map(InterfaceToData, module.interfaces),
-    istr(4, 'unions'):     map(UnionToData, module.unions),
-  }
-
-def ModuleFromData(data):
-  module = mojom.Module()
-  module.kinds = {}
-  for kind in mojom.PRIMITIVES:
-    module.kinds[kind.spec] = kind
-
-  module.values = {}
-
-  module.name = data['name']
-  module.namespace = data['namespace']
-  module.attributes = data['attributes']
-  # Imports must come first, because they add to module.kinds which is used
-  # by by the others.
-  module.imports = map(
-      lambda import_data: ImportFromData(module, import_data),
-      data['imports'])
-
-  # First pass collects kinds.
-  module.enums = map(
-      lambda enum: EnumFromData(module, enum, None), data['enums'])
-  module.structs = map(
-      lambda struct: StructFromData(module, struct), data['structs'])
-  module.unions = map(
-      lambda union: UnionFromData(module, struct), data.get('unions', []))
-  module.interfaces = map(
-      lambda interface: InterfaceFromData(module, interface),
-      data['interfaces'])
-  module.constants = map(
-      lambda constant: ConstantFromData(module, constant, None),
-      data['constants'])
-
-  # Second pass expands fields and methods. This allows fields and parameters
-  # to refer to kinds defined anywhere in the mojom.
-  for struct in module.structs:
-    struct.fields = map(lambda field:
-        FieldFromData(module, field, struct), struct.fields_data)
-    del struct.fields_data
-  for union in module.unions:
-    union.fields = map(lambda field:
-        FieldFromData(module, field, union), union.fields_data)
-    del union.fields_data
-  for interface in module.interfaces:
-    interface.methods = map(lambda method:
-        MethodFromData(module, method, interface), interface.methods_data)
-    del interface.methods_data
-
-  return module
-
-def OrderedModuleFromData(data):
-  module = ModuleFromData(data)
-  for interface in module.interfaces:
-    next_ordinal = 0
-    for method in interface.methods:
-      if method.ordinal is None:
-        method.ordinal = next_ordinal
-      next_ordinal = method.ordinal + 1
-  return module