Uses mojom module names as Dart's package: import URI

mojo/public/tools/bindings/generators/mojom_dart_generator.py

 # Copyright 2014 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.
 
 """Generates dart source files from a mojom.Module."""
 
 import os
 import re
 
 import mojom.generate.generator as generator
@@ skipping 334 matching lines @@
     return getattr(kind, 'dart_map_size', str(kind.length))
   else:
     return 'bindings.kUnspecifiedArrayLength'
 
 def IsPointerArrayKind(kind):
   if not mojom.IsArrayKind(kind):
     return False
   sub_kind = kind.kind
   return mojom.IsObjectKind(sub_kind)
 
+def GetImportUri(module):
+  elements = module.namespace.split('.')
+  elements.append("%s" % module.name)
+  return os.path.join(*elements)
+
 class Generator(generator.Generator):
 
   dart_filters = {
     'array_expected_length': GetArrayExpectedLength,
     'array': GetArrayKind,
     'decode_method': DecodeMethod,
     'default_value': DartDefaultValue,
     'encode_method': EncodeMethod,
     'expression_to_text': ExpressionToText,
     'is_handle': mojom.IsNonInterfaceHandleKind,
@@ skipping 18 matching lines @@
       "interfaces": self.GetInterfaces(),
       "imported_interfaces": self.GetImportedInterfaces(),
       "imported_from": self.ImportedFrom(),
     }
 
   @UseJinja("dart_templates/module.lib.tmpl", filters=dart_filters)
   def GenerateLibModule(self, args):
     return self.GetParameters(args)
 
   def GenerateFiles(self, args):
-    self.Write(self.GenerateLibModule(args),
-        self.MatchMojomFilePath("%s.dart" % self.module.name))
+    elements = self.module.namespace.split('.')
+    elements.append("%s.dart" % self.module.name)
+    path = os.path.join("dart-gen", *elements)
+    self.Write(self.GenerateLibModule(args), path)
+    link = self.MatchMojomFilePath("%s.dart" % self.module.name)
+    if os.path.exists(os.path.join(self.output_dir, link)):
+      os.unlink(os.path.join(self.output_dir, link))
+    os.symlink(os.path.join(self.output_dir, path),
+               os.path.join(self.output_dir, link))
 
   def GetImports(self, args):
-    mojo_root_arg = next(
-        (x for x in args if x.startswith("--dart_mojo_root")), "")
-    (_, _, mojo_root_path) = mojo_root_arg.partition("=")
-    if not mojo_root_path.startswith("//"):
-      raise Exception("Malformed mojo SDK root: " + mojo_root_path)
-    mojo_root_path = mojo_root_path[2:]  # strip //
     used_names = set()
     for each_import in self.module.imports:
       simple_name = each_import["module_name"].split(".")[0]
 
       # Since each import is assigned a library in Dart, they need to have
       # unique names.
       unique_name = simple_name
       counter = 0
       while unique_name in used_names:
         counter += 1
         unique_name = simple_name + str(counter)
 
       used_names.add(unique_name)
       each_import["unique_name"] = unique_name + '_mojom'
       counter += 1
 
-      # At this point, a module's path is reletive to the root of the repo.
-      # However, imports of libraries from the Mojo SDK are always reletive to
-      # root of the Mojo SDK, which may be different from the root of the repo.
-      # This code uses the --dart_mojo_root argument to ensure that Mojo SDK
-      # imports are reletive to the Mojo SDK root.
-      path = each_import['module'].path
-      if os.path.commonprefix([mojo_root_path, path]) == mojo_root_path:
-        path = os.path.relpath(path, mojo_root_path)
-      each_import["rebased_path"] = path
+      each_import["rebased_path"] = GetImportUri(each_import['module'])
     return self.module.imports
 
   def GetImportedInterfaces(self):
     interface_to_import = {}
     for each_import in self.module.imports:
       for each_interface in each_import["module"].interfaces:
         name = each_interface.name
         interface_to_import[name] = each_import["unique_name"] + "." + name
     return interface_to_import
 
   def ImportedFrom(self):
     interface_to_import = {}
     for each_import in self.module.imports:
       for each_interface in each_import["module"].interfaces:
         name = each_interface.name
         interface_to_import[name] = each_import["unique_name"] + "."
     return interface_to_import