diff --git a/.gitignore b/.gitignore
index d72ad58..c04f7f7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -407,7 +407,6 @@
 /tools/grit
 /tools/gyp
 /tools/histograms
-/tools/json_schema_compiler/test/json_schema_compiler_tests.xml
 /tools/metrics/histograms/histograms.before.pretty-print.xml
 /tools/page_cycler/acid3
 /tools/perf/data
diff --git a/PRESUBMIT.py b/PRESUBMIT.py
index 799c534..1f2067d 100644
--- a/PRESUBMIT.py
+++ b/PRESUBMIT.py
@@ -1117,28 +1117,9 @@
   return None
 
 
-def _GetIDLParseError(input_api, filename):
-  try:
-    contents = input_api.ReadFile(filename)
-    idl_schema = input_api.os_path.join(
-        input_api.PresubmitLocalPath(),
-        'tools', 'json_schema_compiler', 'idl_schema.py')
-    process = input_api.subprocess.Popen(
-        [input_api.python_executable, idl_schema],
-        stdin=input_api.subprocess.PIPE,
-        stdout=input_api.subprocess.PIPE,
-        stderr=input_api.subprocess.PIPE,
-        universal_newlines=True)
-    (_, error) = process.communicate(input=contents)
-    return error or None
-  except ValueError as e:
-    return e
-
-
 def _CheckParseErrors(input_api, output_api):
-  """Check that IDL and JSON files do not contain syntax errors."""
+  """Check that JSON files do not contain syntax errors."""
   actions = {
-    '.idl': _GetIDLParseError,
     '.json': _GetJSONParseError,
   }
   # These paths contain test data and other known invalid JSON files.
@@ -1150,11 +1131,6 @@
   json_no_comments_patterns = [
     r'^testing[\\\/]',
   ]
-  # Only run IDL checker on files in these directories.
-  idl_included_patterns = [
-    r'^chrome[\\\/]common[\\\/]extensions[\\\/]api[\\\/]',
-    r'^extensions[\\\/]common[\\\/]api[\\\/]',
-  ]
 
   def get_action(affected_file):
     filename = affected_file.LocalPath()
@@ -1174,10 +1150,6 @@
 
     if MatchesFile(excluded_patterns, path):
       return False
-
-    if (action == _GetIDLParseError and
-        not MatchesFile(idl_included_patterns, path)):
-      return False
     return True
 
   results = []
diff --git a/build/json_schema_api.gni b/build/json_schema_api.gni
deleted file mode 100644
index 5857739..0000000
--- a/build/json_schema_api.gni
+++ /dev/null
@@ -1,209 +0,0 @@
-# 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.
-
-# Defines a static library corresponding to the output of schema compiler tools
-# over a set of extensions API schemas (IDL or JSON format.) The library target
-# has implicit hard dependencies on all schema files listed by the invoker and
-# is itself a hard dependency.
-#
-# Invocations of this template may use the following variables:
-#
-# sources [required] A list of schema files to be compiled.
-#
-# root_namespace [required]
-#     A Python string substituion pattern used to generate the C++
-#     namespace for each API. Use %(namespace)s to replace with the API
-#     namespace, like "toplevel::%(namespace)s_api".
-#
-# schema_include_rules [optional]
-#     A list of paths to include when searching for referenced objects,
-#     with the namespace separated by a :.
-#     Example:
-#       [ '/foo/bar:Foo::Bar::%(namespace)s' ]
-#
-# schemas [optional, default = false]
-#   Boolean indicating if the schema files should be generated.
-#
-# bundle [optional, default = false]
-#   Boolean indicating if the schema bundle files should be generated.
-#
-# bundle_registration [optional, default = false]
-#   Boolean indicating if the API registration bundle files should be generated.
-#
-# impl_dir [required if bundle_registration = true, otherwise unused]
-#   The path containing C++ implementations of API functions. This path is
-#   used as the root path when looking for {schema}/{schema}_api.h headers
-#   when generating API registration bundles. Such headers, if found, are
-#   automatically included by the generated code.
-#
-# uncompiled_sources [optional, only used when bundle = true or
-#     bundle_registration = true]
-#   A list of schema files which should not be compiled, but which should still
-#   be processed for API bundle generation.
-#
-# deps [optional]
-#   If any deps are specified they will be inherited by the static library
-#   target.
-#
-# The static library target also inherits the visibility and output_name
-# of its invoker.
-
-template("json_schema_api") {
-  assert(defined(invoker.sources),
-         "\"sources\" must be defined for the $target_name template.")
-  assert(defined(invoker.root_namespace),
-         "\"root_namespace\" must be defined for the $target_name template.")
-
-  schemas = defined(invoker.schemas) && invoker.schemas
-  bundle = defined(invoker.bundle) && invoker.bundle
-  bundle_registration = defined(invoker.bundle_registration) &&
-      invoker.bundle_registration
-
-  schema_include_rules = ""
-  if (defined(invoker.schema_include_rules)) {
-    schema_include_rules = invoker.schema_include_rules
-  }
-
-  # Keep a copy of the target_name here since it will be trampled
-  # in nested targets.
-  target_visibility = [ ":$target_name" ]
-
-  generated_config_name = target_name + "_generated_config"
-  config(generated_config_name) {
-    include_dirs = [ target_gen_dir ]
-    visibility = target_visibility
-  }
-
-  sources = invoker.sources
-  root_namespace = invoker.root_namespace
-
-  compiler_root = "//tools/json_schema_compiler"
-  compiler_script = "$compiler_root/compiler.py"
-  compiler_sources = [
-    "$compiler_root/cc_generator.py",
-    "$compiler_root/code.py",
-    "$compiler_root/compiler.py",
-    "$compiler_root/cpp_generator.py",
-    "$compiler_root/cpp_type_generator.py",
-    "$compiler_root/cpp_util.py",
-    "$compiler_root/h_generator.py",
-    "$compiler_root/idl_schema.py",
-    "$compiler_root/model.py",
-    "$compiler_root/util_cc_helper.py",
-  ]
-
-  if (schemas) {
-    schema_generator_name = target_name + "_schema_generator"
-    action_foreach(schema_generator_name) {
-      script = compiler_script
-      inputs = compiler_sources
-      outputs = [
-        "$target_gen_dir/{{source_name_part}}.cc",
-        "$target_gen_dir/{{source_name_part}}.h",
-      ]
-      args = [
-        "{{source}}",
-        "--root=" + rebase_path("//", root_build_dir),
-        "--destdir=" + rebase_path(root_gen_dir, root_build_dir),
-        "--namespace=$root_namespace",
-        "--generator=cpp",
-        "--include-rules=$schema_include_rules" ]
-
-      if (defined(invoker.visibility)) {
-        # If visibility is restricted, add our own target to it.
-        visibility = [ invoker.visibility, target_visibility ]
-      }
-    }
-  }
-
-  if (bundle) {
-    uncompiled_sources = []
-    if (defined(invoker.uncompiled_sources)) {
-     uncompiled_sources = invoker.uncompiled_sources
-    }
-
-    bundle_generator_schema_name = target_name + "_bundle_generator_schema"
-    action(bundle_generator_schema_name) {
-      script = compiler_script
-      inputs = compiler_sources + sources + uncompiled_sources
-      outputs = [
-        "$target_gen_dir/generated_schemas.cc",
-        "$target_gen_dir/generated_schemas.h",
-      ]
-      args = [
-        "--root=" + rebase_path("//", root_build_dir),
-        "--destdir=" + rebase_path(root_gen_dir, root_build_dir),
-        "--namespace=$root_namespace",
-        "--generator=cpp-bundle-schema",
-        "--include-rules=$schema_include_rules" ]
-        + rebase_path(sources, root_build_dir)
-        + rebase_path(uncompiled_sources, root_build_dir)
-    }
-  }
-
-  if (bundle_registration) {
-    uncompiled_sources = []
-    if (defined(invoker.uncompiled_sources)) {
-     uncompiled_sources = invoker.uncompiled_sources
-    }
-
-    assert(defined(invoker.impl_dir),
-           "\"impl_dir\" must be defined for the $target_name template.")
-    impl_dir = invoker.impl_dir
-
-    bundle_generator_registration_name = target_name +
-        "_bundle_generator_registration"
-    action(bundle_generator_registration_name) {
-      script = compiler_script
-      inputs = compiler_sources + sources + uncompiled_sources
-      outputs = [
-        "$root_gen_dir/$impl_dir/generated_api_registration.cc",
-        "$root_gen_dir/$impl_dir/generated_api_registration.h",
-      ]
-      args = [
-        "--root=" + rebase_path("//", root_build_dir),
-        "--destdir=" + rebase_path(root_gen_dir, root_build_dir),
-        "--namespace=$root_namespace",
-        "--generator=cpp-bundle-registration",
-        "--impl-dir=" + rebase_path(impl_dir, "//"),
-        "--include-rules=$schema_include_rules" ]
-        + rebase_path(sources, root_build_dir)
-        + rebase_path(uncompiled_sources, root_build_dir)
-    }
-  }
-
-  source_set(target_name) {
-    sources = []
-    deps = []
-    public_deps = []
-
-    if (schemas) {
-      sources += get_target_outputs(":$schema_generator_name")
-      public_deps += [ ":$schema_generator_name" ]
-      deps += [ "//tools/json_schema_compiler:generated_api_util" ]
-    }
-
-    if (bundle) {
-      sources += get_target_outputs(":$bundle_generator_schema_name")
-      deps += [ ":$bundle_generator_schema_name" ]
-    }
-
-    if (bundle_registration) {
-      sources += get_target_outputs(":$bundle_generator_registration_name")
-      deps += [ ":$bundle_generator_registration_name" ]
-    }
-
-    if (defined(invoker.deps)) {
-      deps += invoker.deps
-    }
-    public_configs = [ ":$generated_config_name" ]
-
-    if (defined(invoker.visibility)) {
-      visibility = invoker.visibility
-    }
-    if (defined(invoker.output_name)) {
-      output_name = invoker.output_name
-    }
-  }
-}
diff --git a/build/json_schema_bundle_compile.gypi b/build/json_schema_bundle_compile.gypi
deleted file mode 100644
index a302013..0000000
--- a/build/json_schema_bundle_compile.gypi
+++ /dev/null
@@ -1,83 +0,0 @@
-# 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.
-
-{
-  'variables': {
-    # When including this gypi, the following variables must be set:
-    #   schema_files:
-    #     An array of json or idl files that comprise the api model.
-    #   schema_include_rules (optional):
-    #     An array of paths to include when searching for referenced objects,
-    #     with the namespace separated by a :.
-    #     Example:
-    #       [ '/foo/bar:Foo::Bar::%(namespace)s' ]
-    #   cc_dir:
-    #     The directory to put the generated code in.
-    #   root_namespace:
-    #     A Python string substituion pattern used to generate the C++
-    #     namespace for each API. Use %(namespace)s to replace with the API
-    #     namespace, like "toplevel::%(namespace)s_api".
-    #
-    # Functions and namespaces can be excluded by setting "nocompile" to true.
-    # The default root path of API implementation sources is
-    # chrome/browser/extensions/api and can be overridden by setting "impl_dir".
-    'api_gen_dir': '<(DEPTH)/tools/json_schema_compiler',
-    'api_gen': '<(api_gen_dir)/compiler.py',
-    'generator_files': [
-      '<(api_gen_dir)/cc_generator.py',
-      '<(api_gen_dir)/code.py',
-      '<(api_gen_dir)/compiler.py',
-      '<(api_gen_dir)/cpp_bundle_generator.py',
-      '<(api_gen_dir)/cpp_type_generator.py',
-      '<(api_gen_dir)/cpp_util.py',
-      '<(api_gen_dir)/h_generator.py',
-      '<(api_gen_dir)/idl_schema.py',
-      '<(api_gen_dir)/json_schema.py',
-      '<(api_gen_dir)/model.py',
-      '<(api_gen_dir)/util_cc_helper.py',
-    ],
-    'schema_include_rules': [],
-  },
-  'actions': [
-    {
-      'action_name': 'genapi_bundle_schema',
-      'inputs': [
-        '<@(generator_files)',
-        '<@(schema_files)',
-        '<@(non_compiled_schema_files)',
-      ],
-      'outputs': [
-        '<(SHARED_INTERMEDIATE_DIR)/<(cc_dir)/generated_schemas.h',
-        '<(SHARED_INTERMEDIATE_DIR)/<(cc_dir)/generated_schemas.cc',
-      ],
-      'action': [
-        'python',
-        '<(api_gen)',
-        '--root=<(DEPTH)',
-        '--destdir=<(SHARED_INTERMEDIATE_DIR)',
-        '--namespace=<(root_namespace)',
-        '--generator=cpp-bundle-schema',
-        '--include-rules=<(schema_include_rules)',
-        '<@(schema_files)',
-        '<@(non_compiled_schema_files)',
-      ],
-      'message': 'Generating C++ API bundle code for schemas',
-      'process_outputs_as_sources': 1,
-      # Avoid running MIDL compiler on IDL input files.
-      'explicit_idl_action': 1,
-    },
-  ],
-  'include_dirs': [
-    '<(SHARED_INTERMEDIATE_DIR)',
-    '<(DEPTH)',
-  ],
-  'direct_dependent_settings': {
-    'include_dirs': [
-      '<(SHARED_INTERMEDIATE_DIR)',
-    ]
-  },
-  # This target exports a hard dependency because it generates header
-  # files.
-  'hard_dependency': 1,
-}
diff --git a/build/json_schema_bundle_registration_compile.gypi b/build/json_schema_bundle_registration_compile.gypi
deleted file mode 100644
index 8c5af4e..0000000
--- a/build/json_schema_bundle_registration_compile.gypi
+++ /dev/null
@@ -1,78 +0,0 @@
-# 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.
-
-{
-  'variables': {
-    # When including this gypi, the following variables must be set:
-    #   schema_files:
-    #     An array of json or idl files that comprise the api model.
-    #   impl_dir_:
-    #     The root path of API implementations; also used for the
-    #     output location. (N.B. Named as such to prevent gyp from
-    #     expanding it as a relative path.)
-    #   root_namespace:
-    #     A Python string substituion pattern used to generate the C++
-    #     namespace for each API. Use %(namespace)s to replace with the API
-    #     namespace, like "toplevel::%(namespace)s_api".
-    #
-    # Functions and namespaces can be excluded by setting "nocompile" to true.
-    'api_gen_dir': '<(DEPTH)/tools/json_schema_compiler',
-    'api_gen': '<(api_gen_dir)/compiler.py',
-    'generator_files': [
-      '<(api_gen_dir)/cc_generator.py',
-      '<(api_gen_dir)/code.py',
-      '<(api_gen_dir)/compiler.py',
-      '<(api_gen_dir)/cpp_bundle_generator.py',
-      '<(api_gen_dir)/cpp_type_generator.py',
-      '<(api_gen_dir)/cpp_util.py',
-      '<(api_gen_dir)/h_generator.py',
-      '<(api_gen_dir)/idl_schema.py',
-      '<(api_gen_dir)/json_schema.py',
-      '<(api_gen_dir)/model.py',
-      '<(api_gen_dir)/util_cc_helper.py',
-    ],
-  },
-  'actions': [
-    {
-      # GN version: json_schema_api.gni
-      'action_name': 'genapi_bundle_registration',
-      'inputs': [
-        '<@(generator_files)',
-        '<@(schema_files)',
-        '<@(non_compiled_schema_files)',
-      ],
-      'outputs': [
-        '<(SHARED_INTERMEDIATE_DIR)/<(impl_dir_)/generated_api_registration.h',
-        '<(SHARED_INTERMEDIATE_DIR)/<(impl_dir_)/generated_api_registration.cc',
-      ],
-      'action': [
-        'python',
-        '<(api_gen)',
-        '--root=<(DEPTH)',
-        '--destdir=<(SHARED_INTERMEDIATE_DIR)',
-        '--namespace=<(root_namespace)',
-        '--generator=cpp-bundle-registration',
-        '--impl-dir=<(impl_dir_)',
-        '<@(schema_files)',
-        '<@(non_compiled_schema_files)',
-      ],
-      'message': 'Generating C++ API bundle code for function registration',
-      'process_outputs_as_sources': 1,
-      # Avoid running MIDL compiler on IDL input files.
-      'explicit_idl_action': 1,
-    },
-  ],
-  'include_dirs': [
-    '<(SHARED_INTERMEDIATE_DIR)',
-    '<(DEPTH)',
-  ],
-  'direct_dependent_settings': {
-    'include_dirs': [
-      '<(SHARED_INTERMEDIATE_DIR)',
-    ]
-  },
-  # This target exports a hard dependency because it generates header
-  # files.
-  'hard_dependency': 1,
-}
diff --git a/build/json_schema_compile.gypi b/build/json_schema_compile.gypi
deleted file mode 100644
index 6e5727a..0000000
--- a/build/json_schema_compile.gypi
+++ /dev/null
@@ -1,123 +0,0 @@
-# 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.
-
-{
-  'variables': {
-    # When including this gypi, the following variables must be set:
-    #   schema_files:
-    #     An array of json or idl files that comprise the api model.
-    #   schema_include_rules (optional):
-    #     An array of paths to include when searching for referenced objects,
-    #     with the namespace separated by a :.
-    #     Example:
-    #       [ '/foo/bar:Foo::Bar::%(namespace)s' ]
-    #   cc_dir:
-    #     The directory to put the generated code in.
-    #   root_namespace:
-    #     A Python string substituion pattern used to generate the C++
-    #     namespace for each API. Use %(namespace)s to replace with the API
-    #     namespace, like "toplevel::%(namespace)s_api".
-    #
-    # Functions and namespaces can be excluded by setting "nocompile" to true.
-    'api_gen_dir': '<(DEPTH)/tools/json_schema_compiler',
-    'api_gen': '<(api_gen_dir)/compiler.py',
-    'schema_include_rules': [],
-  },
-  'rules': [
-    {
-      # GN version: json_schema_api.gni
-      'rule_name': 'genapi',
-      'msvs_external_rule': 1,
-      'extension': 'json',
-      'inputs': [
-        '<(api_gen_dir)/cc_generator.py',
-        '<(api_gen_dir)/code.py',
-        '<(api_gen_dir)/compiler.py',
-        '<(api_gen_dir)/cpp_generator.py',
-        '<(api_gen_dir)/cpp_type_generator.py',
-        '<(api_gen_dir)/cpp_util.py',
-        '<(api_gen_dir)/h_generator.py',
-        '<(api_gen_dir)/json_schema.py',
-        '<(api_gen_dir)/model.py',
-        '<(api_gen_dir)/util.cc',
-        '<(api_gen_dir)/util.h',
-        '<(api_gen_dir)/util_cc_helper.py',
-        # TODO(calamity): uncomment this when gyp on windows behaves like other
-        # platforms. List expansions of filepaths in inputs expand to different
-        # things.
-        # '<@(schema_files)',
-      ],
-      'outputs': [
-        '<(SHARED_INTERMEDIATE_DIR)/<(cc_dir)/<(RULE_INPUT_DIRNAME)/<(RULE_INPUT_ROOT).cc',
-        '<(SHARED_INTERMEDIATE_DIR)/<(cc_dir)/<(RULE_INPUT_DIRNAME)/<(RULE_INPUT_ROOT).h',
-      ],
-      'action': [
-        'python',
-        '<(api_gen)',
-        '<(RULE_INPUT_PATH)',
-        '--root=<(DEPTH)',
-        '--destdir=<(SHARED_INTERMEDIATE_DIR)',
-        '--namespace=<(root_namespace)',
-        '--generator=cpp',
-        '--include-rules=<(schema_include_rules)'
-      ],
-      'message': 'Generating C++ code from <(RULE_INPUT_PATH) json files',
-      'process_outputs_as_sources': 1,
-    },
-    {
-      'rule_name': 'genapi_idl',
-      'msvs_external_rule': 1,
-      'extension': 'idl',
-      'inputs': [
-        '<(api_gen_dir)/cc_generator.py',
-        '<(api_gen_dir)/code.py',
-        '<(api_gen_dir)/compiler.py',
-        '<(api_gen_dir)/cpp_generator.py',
-        '<(api_gen_dir)/cpp_type_generator.py',
-        '<(api_gen_dir)/cpp_util.py',
-        '<(api_gen_dir)/h_generator.py',
-        '<(api_gen_dir)/idl_schema.py',
-        '<(api_gen_dir)/model.py',
-        '<(api_gen_dir)/util.cc',
-        '<(api_gen_dir)/util.h',
-        '<(api_gen_dir)/util_cc_helper.py',
-        # TODO(calamity): uncomment this when gyp on windows behaves like other
-        # platforms. List expansions of filepaths in inputs expand to different
-        # things.
-        # '<@(schema_files)',
-      ],
-      'outputs': [
-        '<(SHARED_INTERMEDIATE_DIR)/<(cc_dir)/<(RULE_INPUT_DIRNAME)/<(RULE_INPUT_ROOT).cc',
-        '<(SHARED_INTERMEDIATE_DIR)/<(cc_dir)/<(RULE_INPUT_DIRNAME)/<(RULE_INPUT_ROOT).h',
-      ],
-      'action': [
-        'python',
-        '<(api_gen)',
-        '<(RULE_INPUT_PATH)',
-        '--root=<(DEPTH)',
-        '--destdir=<(SHARED_INTERMEDIATE_DIR)',
-        '--namespace=<(root_namespace)',
-        '--generator=cpp',
-        '--include-rules=<(schema_include_rules)'
-      ],
-      'message': 'Generating C++ code from <(RULE_INPUT_PATH) IDL files',
-      'process_outputs_as_sources': 1,
-    },
-  ],
-  'include_dirs': [
-    '<(SHARED_INTERMEDIATE_DIR)',
-    '<(DEPTH)',
-  ],
-  'dependencies':[
-    '<(DEPTH)/tools/json_schema_compiler/api_gen_util.gyp:api_gen_util',
-  ],
-  'direct_dependent_settings': {
-    'include_dirs': [
-      '<(SHARED_INTERMEDIATE_DIR)',
-    ]
-  },
-  # This target exports a hard dependency because it generates header
-  # files.
-  'hard_dependency': 1,
-}
diff --git a/build/json_to_struct.gypi b/build/json_to_struct.gypi
deleted file mode 100644
index 57271c8..0000000
--- a/build/json_to_struct.gypi
+++ /dev/null
@@ -1,50 +0,0 @@
-# Copyright 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.
-
-{
-  'variables': {
-    # When including this gypi, the following variables must be set:
-    #   schema_file: a json file that comprise the structure model.
-    #   namespace: the C++ namespace that all generated files go under
-    #   cc_dir: path to generated files
-    # Functions and namespaces can be excluded by setting "nocompile" to true.
-    'struct_gen_dir': '<(DEPTH)/tools/json_to_struct',
-    'struct_gen': '<(struct_gen_dir)/json_to_struct.py',
-  },
-  'rules': [
-    {
-      # GN version: //tools/json_to_struct/json_to_struct.gni
-      'rule_name': 'genstaticinit',
-      'extension': 'json',
-      'inputs': [
-        '<(struct_gen_dir)/element_generator.py',
-        '<(struct_gen_dir)/json_to_struct.py',
-        '<(struct_gen_dir)/struct_generator.py',
-        '<(schema_file)',
-      ],
-      'outputs': [
-        '<(SHARED_INTERMEDIATE_DIR)/<(cc_dir)/<(RULE_INPUT_ROOT).cc',
-        '<(SHARED_INTERMEDIATE_DIR)/<(cc_dir)/<(RULE_INPUT_ROOT).h',
-      ],
-      'action': [
-        'python',
-        '<(struct_gen)',
-        '<(RULE_INPUT_PATH)',
-        '--destbase=<(SHARED_INTERMEDIATE_DIR)',
-        '--destdir=<(cc_dir)',
-        '--namespace=<(namespace)',
-        '--schema=<(schema_file)',
-      ],
-      'message': 'Generating C++ static initializers from <(RULE_INPUT_PATH)',
-      'process_outputs_as_sources': 1,
-    },
-  ],
-  'include_dirs': [
-    '<(SHARED_INTERMEDIATE_DIR)',
-    '<(DEPTH)',
-  ],
-  # This target exports a hard dependency because it generates header
-  # files.
-  'hard_dependency': 1,
-}
diff --git a/mojo/tools/roll/rev.py b/mojo/tools/roll/rev.py
index 242818f..3efbec5 100755
--- a/mojo/tools/roll/rev.py
+++ b/mojo/tools/roll/rev.py
@@ -59,7 +59,6 @@
     "tools/gritsettings",
     "tools/idl_parser",
     "tools/json_comment_eater",
-    "tools/json_schema_compiler",
     "tools/linux",
     "tools/lsan",
     "tools/msan",
diff --git a/tools/json_schema_compiler/BUILD.gn b/tools/json_schema_compiler/BUILD.gn
deleted file mode 100644
index 2d7c183..0000000
--- a/tools/json_schema_compiler/BUILD.gn
+++ /dev/null
@@ -1,13 +0,0 @@
-# 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.
-
-# Utility sources against which generated API modules should be linked.
-source_set("generated_api_util") {
-  sources = [
-    "util.cc",
-    "util.h"
-  ]
-  deps = [ "//base" ]
-}
-
diff --git a/tools/json_schema_compiler/PRESUBMIT.py b/tools/json_schema_compiler/PRESUBMIT.py
deleted file mode 100644
index b98649b..0000000
--- a/tools/json_schema_compiler/PRESUBMIT.py
+++ /dev/null
@@ -1,20 +0,0 @@
-# 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.
-
-"""Presubmit script for changes affecting tools/json_schema_compiler/
-
-See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
-for more details about the presubmit API built into gcl.
-"""
-
-WHITELIST = [ r'.+_test.py$' ]
-
-def CheckChangeOnUpload(input_api, output_api):
-  return input_api.canned_checks.RunUnitTestsInDirectory(
-      input_api, output_api, '.', whitelist=WHITELIST)
-
-
-def CheckChangeOnCommit(input_api, output_api):
-  return input_api.canned_checks.RunUnitTestsInDirectory(
-      input_api, output_api, '.', whitelist=WHITELIST)
diff --git a/tools/json_schema_compiler/api_gen_util.gyp b/tools/json_schema_compiler/api_gen_util.gyp
deleted file mode 100644
index 54966cc..0000000
--- a/tools/json_schema_compiler/api_gen_util.gyp
+++ /dev/null
@@ -1,20 +0,0 @@
-# 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.
-
-{
-  'variables': {
-    'chromium_code': 1,
-  },
-  'targets': [{
-    'target_name': 'api_gen_util',
-    'type': 'static_library',
-    'sources': [
-        'util.cc',
-    ],
-    'dependencies': ['<(DEPTH)/base/base.gyp:base'],
-    'include_dirs': [
-      '<(DEPTH)',
-    ],
-  }],
-}
diff --git a/tools/json_schema_compiler/cc_generator.py b/tools/json_schema_compiler/cc_generator.py
deleted file mode 100644
index 1d243f0..0000000
--- a/tools/json_schema_compiler/cc_generator.py
+++ /dev/null
@@ -1,1070 +0,0 @@
-# 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.
-
-from code import Code
-from model import PropertyType
-import cpp_util
-import schema_util
-import util_cc_helper
-from cpp_namespace_environment import CppNamespaceEnvironment
-
-class CCGenerator(object):
-  def __init__(self, type_generator):
-    self._type_generator = type_generator
-
-  def Generate(self, namespace):
-    return _Generator(namespace, self._type_generator).Generate()
-
-
-class _Generator(object):
-  """A .cc generator for a namespace.
-  """
-  def __init__(self, namespace, cpp_type_generator):
-    assert type(namespace.environment) is CppNamespaceEnvironment
-    self._namespace = namespace
-    self._type_helper = cpp_type_generator
-    self._util_cc_helper = (
-        util_cc_helper.UtilCCHelper(self._type_helper))
-    self._generate_error_messages = namespace.compiler_options.get(
-        'generate_error_messages', False)
-
-  def Generate(self):
-    """Generates a Code object with the .cc for a single namespace.
-    """
-    cpp_namespace = cpp_util.GetCppNamespace(
-        self._namespace.environment.namespace_pattern,
-        self._namespace.unix_name)
-
-    c = Code()
-    (c.Append(cpp_util.CHROMIUM_LICENSE)
-      .Append()
-      .Append(cpp_util.GENERATED_FILE_MESSAGE % self._namespace.source_file)
-      .Append()
-      .Append(self._util_cc_helper.GetIncludePath())
-      .Append('#include "base/logging.h"')
-      .Append('#include "base/strings/string_number_conversions.h"')
-      .Append('#include "base/strings/utf_string_conversions.h"')
-      .Append('#include "%s/%s.h"' %
-              (self._namespace.source_file_dir, self._namespace.short_filename))
-      .Append('#include <set>')
-      .Cblock(self._type_helper.GenerateIncludes(include_soft=True))
-      .Append()
-      .Append('using base::UTF8ToUTF16;')
-      .Append()
-      .Concat(cpp_util.OpenNamespace(cpp_namespace))
-    )
-    if self._namespace.properties:
-      (c.Append('//')
-        .Append('// Properties')
-        .Append('//')
-        .Append()
-      )
-      for property in self._namespace.properties.values():
-        property_code = self._type_helper.GeneratePropertyValues(
-            property,
-            'const %(type)s %(name)s = %(value)s;',
-            nodoc=True)
-        if property_code:
-          c.Cblock(property_code)
-    if self._namespace.types:
-      (c.Append('//')
-        .Append('// Types')
-        .Append('//')
-        .Append()
-        .Cblock(self._GenerateTypes(None, self._namespace.types.values()))
-      )
-    if self._namespace.functions:
-      (c.Append('//')
-        .Append('// Functions')
-        .Append('//')
-        .Append()
-      )
-    for function in self._namespace.functions.values():
-      c.Cblock(self._GenerateFunction(function))
-    if self._namespace.events:
-      (c.Append('//')
-        .Append('// Events')
-        .Append('//')
-        .Append()
-      )
-      for event in self._namespace.events.values():
-        c.Cblock(self._GenerateEvent(event))
-    c.Cblock(cpp_util.CloseNamespace(cpp_namespace))
-    c.Append()
-    return c
-
-  def _GenerateType(self, cpp_namespace, type_):
-    """Generates the function definitions for a type.
-    """
-    classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
-    c = Code()
-
-    if type_.functions:
-      # Wrap functions within types in the type's namespace.
-      (c.Append('namespace %s {' % classname)
-        .Append())
-      for function in type_.functions.values():
-        c.Cblock(self._GenerateFunction(function))
-      c.Append('}  // namespace %s' % classname)
-    elif type_.property_type == PropertyType.ARRAY:
-      c.Cblock(self._GenerateType(cpp_namespace, type_.item_type))
-    elif type_.property_type in (PropertyType.CHOICES,
-                                 PropertyType.OBJECT):
-      if cpp_namespace is None:
-        classname_in_namespace = classname
-      else:
-        classname_in_namespace = '%s::%s' % (cpp_namespace, classname)
-
-      if type_.property_type == PropertyType.OBJECT:
-        c.Cblock(self._GeneratePropertyFunctions(classname_in_namespace,
-                                                 type_.properties.values()))
-      else:
-        c.Cblock(self._GenerateTypes(classname_in_namespace, type_.choices))
-
-      (c.Append('%s::%s()' % (classname_in_namespace, classname))
-        .Cblock(self._GenerateInitializersAndBody(type_))
-        .Append('%s::~%s() {}' % (classname_in_namespace, classname))
-        .Append()
-      )
-      if type_.origin.from_json:
-        c.Cblock(self._GenerateTypePopulate(classname_in_namespace, type_))
-        if cpp_namespace is None:  # only generate for top-level types
-          c.Cblock(self._GenerateTypeFromValue(classname_in_namespace, type_))
-      if type_.origin.from_client:
-        c.Cblock(self._GenerateTypeToValue(classname_in_namespace, type_))
-    elif type_.property_type == PropertyType.ENUM:
-      (c.Cblock(self._GenerateEnumToString(cpp_namespace, type_))
-        .Cblock(self._GenerateEnumFromString(cpp_namespace, type_))
-      )
-
-    return c
-
-  def _GenerateInitializersAndBody(self, type_):
-    items = []
-    for prop in type_.properties.values():
-      t = prop.type_
-
-      real_t = self._type_helper.FollowRef(t)
-      if real_t.property_type == PropertyType.ENUM:
-        items.append('%s(%s)' % (
-            prop.unix_name,
-            self._type_helper.GetEnumNoneValue(t)))
-      elif prop.optional:
-        continue
-      elif t.property_type == PropertyType.INTEGER:
-        items.append('%s(0)' % prop.unix_name)
-      elif t.property_type == PropertyType.DOUBLE:
-        items.append('%s(0.0)' % prop.unix_name)
-      elif t.property_type == PropertyType.BOOLEAN:
-        items.append('%s(false)' % prop.unix_name)
-      elif (t.property_type == PropertyType.ANY or
-            t.property_type == PropertyType.ARRAY or
-            t.property_type == PropertyType.BINARY or  # mapped to std::string
-            t.property_type == PropertyType.CHOICES or
-            t.property_type == PropertyType.OBJECT or
-            t.property_type == PropertyType.FUNCTION or
-            t.property_type == PropertyType.REF or
-            t.property_type == PropertyType.STRING):
-        # TODO(miket): It would be nice to initialize CHOICES, but we
-        # don't presently have the semantics to indicate which one of a set
-        # should be the default.
-        continue
-      else:
-        raise TypeError(t)
-
-    if items:
-      s = ': %s' % (', '.join(items))
-    else:
-      s = ''
-    s = s + ' {}'
-    return Code().Append(s)
-
-  def _GenerateTypePopulate(self, cpp_namespace, type_):
-    """Generates the function for populating a type given a pointer to it.
-
-    E.g for type "Foo", generates Foo::Populate()
-    """
-    classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
-    c = Code()
-    (c.Append('// static')
-      .Append('bool %(namespace)s::Populate(')
-      .Sblock('    %s) {' % self._GenerateParams(
-          ('const base::Value& value', '%(name)s* out'))))
-
-    if self._generate_error_messages:
-      c.Append('DCHECK(error);')
-
-    if type_.property_type == PropertyType.CHOICES:
-      for choice in type_.choices:
-        (c.Sblock('if (%s) {' % self._GenerateValueIsTypeExpression('value',
-                                                                    choice))
-            .Concat(self._GeneratePopulateVariableFromValue(
-                choice,
-                '(&value)',
-                'out->as_%s' % choice.unix_name,
-                'false',
-                is_ptr=True))
-            .Append('return true;')
-          .Eblock('}')
-        )
-      (c.Concat(self._GenerateError(
-          '"expected %s, got " +  %s' %
-              (" or ".join(choice.name for choice in type_.choices),
-              self._util_cc_helper.GetValueTypeString('value'))))
-        .Append('return false;'))
-    elif type_.property_type == PropertyType.OBJECT:
-      (c.Sblock('if (!value.IsType(base::Value::TYPE_DICTIONARY)) {')
-        .Concat(self._GenerateError(
-          '"expected dictionary, got " + ' +
-          self._util_cc_helper.GetValueTypeString('value')))
-        .Append('return false;')
-        .Eblock('}'))
-
-      if type_.properties or type_.additional_properties is not None:
-        c.Append('const base::DictionaryValue* dict = '
-                     'static_cast<const base::DictionaryValue*>(&value);')
-        if self._generate_error_messages:
-            c.Append('std::set<std::string> keys;')
-      for prop in type_.properties.itervalues():
-        c.Concat(self._InitializePropertyToDefault(prop, 'out'))
-      for prop in type_.properties.itervalues():
-        if self._generate_error_messages:
-          c.Append('keys.insert("%s");' % (prop.name))
-        c.Concat(self._GenerateTypePopulateProperty(prop, 'dict', 'out'))
-      # Check for extra values.
-      if self._generate_error_messages:
-        (c.Sblock('for (base::DictionaryValue::Iterator it(*dict); '
-                       '!it.IsAtEnd(); it.Advance()) {')
-          .Sblock('if (!keys.count(it.key())) {')
-          .Concat(self._GenerateError('"found unexpected key \'" + '
-                                          'it.key() + "\'"'))
-          .Eblock('}')
-          .Eblock('}')
-        )
-      if type_.additional_properties is not None:
-        if type_.additional_properties.property_type == PropertyType.ANY:
-          c.Append('out->additional_properties.MergeDictionary(dict);')
-        else:
-          cpp_type = self._type_helper.GetCppType(type_.additional_properties,
-                                                  is_in_container=True)
-          (c.Append('for (base::DictionaryValue::Iterator it(*dict);')
-            .Sblock('     !it.IsAtEnd(); it.Advance()) {')
-              .Append('%s tmp;' % cpp_type)
-              .Concat(self._GeneratePopulateVariableFromValue(
-                  type_.additional_properties,
-                  '(&it.value())',
-                  'tmp',
-                  'false'))
-              .Append('out->additional_properties[it.key()] = tmp;')
-            .Eblock('}')
-          )
-      c.Append('return true;')
-    (c.Eblock('}')
-      .Substitute({'namespace': cpp_namespace, 'name': classname}))
-    return c
-
-  def _GenerateValueIsTypeExpression(self, var, type_):
-    real_type = self._type_helper.FollowRef(type_)
-    if real_type.property_type is PropertyType.CHOICES:
-      return '(%s)' % ' || '.join(self._GenerateValueIsTypeExpression(var,
-                                                                      choice)
-                                  for choice in real_type.choices)
-    return '%s.IsType(%s)' % (var, cpp_util.GetValueType(real_type))
-
-  def _GenerateTypePopulateProperty(self, prop, src, dst):
-    """Generate the code to populate a single property in a type.
-
-    src: base::DictionaryValue*
-    dst: Type*
-    """
-    c = Code()
-    value_var = prop.unix_name + '_value'
-    c.Append('const base::Value* %(value_var)s = NULL;')
-    if prop.optional:
-      (c.Sblock(
-          'if (%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {')
-        .Concat(self._GeneratePopulatePropertyFromValue(
-            prop, value_var, dst, 'false')))
-      underlying_type = self._type_helper.FollowRef(prop.type_)
-      if underlying_type.property_type == PropertyType.ENUM:
-        (c.Append('} else {')
-          .Append('%%(dst)s->%%(name)s = %s;' %
-              self._type_helper.GetEnumNoneValue(prop.type_)))
-      c.Eblock('}')
-    else:
-      (c.Sblock(
-          'if (!%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {')
-        .Concat(self._GenerateError('"\'%%(key)s\' is required"'))
-        .Append('return false;')
-        .Eblock('}')
-        .Concat(self._GeneratePopulatePropertyFromValue(
-            prop, value_var, dst, 'false'))
-      )
-    c.Append()
-    c.Substitute({
-      'value_var': value_var,
-      'key': prop.name,
-      'src': src,
-      'dst': dst,
-      'name': prop.unix_name
-    })
-    return c
-
-  def _GenerateTypeFromValue(self, cpp_namespace, type_):
-    classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
-    c = Code()
-    (c.Append('// static')
-      .Append('scoped_ptr<%s> %s::FromValue(%s) {' % (classname,
-        cpp_namespace, self._GenerateParams(('const base::Value& value',))))
-    )
-    if self._generate_error_messages:
-      c.Append('DCHECK(error);')
-    (c.Append('  scoped_ptr<%s> out(new %s());' % (classname, classname))
-      .Append('  if (!Populate(%s))' % self._GenerateArgs(
-          ('value', 'out.get()')))
-      .Append('    return scoped_ptr<%s>();' % classname)
-      .Append('  return out.Pass();')
-      .Append('}')
-    )
-    return c
-
-  def _GenerateTypeToValue(self, cpp_namespace, type_):
-    """Generates a function that serializes the type into a base::Value.
-    E.g. for type "Foo" generates Foo::ToValue()
-    """
-    if type_.property_type == PropertyType.OBJECT:
-      return self._GenerateObjectTypeToValue(cpp_namespace, type_)
-    elif type_.property_type == PropertyType.CHOICES:
-      return self._GenerateChoiceTypeToValue(cpp_namespace, type_)
-    else:
-      raise ValueError("Unsupported property type %s" % type_.type_)
-
-  def _GenerateObjectTypeToValue(self, cpp_namespace, type_):
-    """Generates a function that serializes an object-representing type
-    into a base::DictionaryValue.
-    """
-    c = Code()
-    (c.Sblock('scoped_ptr<base::DictionaryValue> %s::ToValue() const {' %
-          cpp_namespace)
-        .Append('scoped_ptr<base::DictionaryValue> value('
-                    'new base::DictionaryValue());')
-        .Append()
-    )
-
-    for prop in type_.properties.values():
-      prop_var = 'this->%s' % prop.unix_name
-      if prop.optional:
-        # Optional enum values are generated with a NONE enum value.
-        underlying_type = self._type_helper.FollowRef(prop.type_)
-        if underlying_type.property_type == PropertyType.ENUM:
-          c.Sblock('if (%s != %s) {' %
-              (prop_var,
-               self._type_helper.GetEnumNoneValue(prop.type_)))
-        else:
-          c.Sblock('if (%s.get()) {' % prop_var)
-
-      # ANY is a base::Value which is abstract and cannot be a direct member, so
-      # it will always be a pointer.
-      is_ptr = prop.optional or prop.type_.property_type == PropertyType.ANY
-      c.Cblock(self._CreateValueFromType(
-          'value->SetWithoutPathExpansion("%s", %%s);' % prop.name,
-          prop.name,
-          prop.type_,
-          prop_var,
-          is_ptr=is_ptr))
-
-      if prop.optional:
-        c.Eblock('}')
-
-    if type_.additional_properties is not None:
-      if type_.additional_properties.property_type == PropertyType.ANY:
-        c.Append('value->MergeDictionary(&additional_properties);')
-      else:
-        # Non-copyable types will be wrapped in a linked_ptr for inclusion in
-        # maps, so we need to unwrap them.
-        needs_unwrap = (
-            not self._type_helper.IsCopyable(type_.additional_properties))
-        cpp_type = self._type_helper.GetCppType(type_.additional_properties,
-                                                is_in_container=True)
-        (c.Sblock('for (std::map<std::string, %s>::const_iterator it =' %
-                      cpp_util.PadForGenerics(cpp_type))
-          .Append('       additional_properties.begin();')
-          .Append('   it != additional_properties.end(); ++it) {')
-          .Cblock(self._CreateValueFromType(
-              'value->SetWithoutPathExpansion(it->first, %s);',
-              type_.additional_properties.name,
-              type_.additional_properties,
-              '%sit->second' % ('*' if needs_unwrap else '')))
-          .Eblock('}')
-        )
-
-    return (c.Append()
-             .Append('return value.Pass();')
-           .Eblock('}'))
-
-  def _GenerateChoiceTypeToValue(self, cpp_namespace, type_):
-    """Generates a function that serializes a choice-representing type
-    into a base::Value.
-    """
-    c = Code()
-    c.Sblock('scoped_ptr<base::Value> %s::ToValue() const {' % cpp_namespace)
-    c.Append('scoped_ptr<base::Value> result;')
-    for choice in type_.choices:
-      choice_var = 'as_%s' % choice.unix_name
-      (c.Sblock('if (%s) {' % choice_var)
-          .Append('DCHECK(!result) << "Cannot set multiple choices for %s";' %
-                      type_.unix_name)
-          .Cblock(self._CreateValueFromType('result.reset(%s);',
-                                            choice.name,
-                                            choice,
-                                            '*%s' % choice_var))
-        .Eblock('}')
-      )
-    (c.Append('DCHECK(result) << "Must set at least one choice for %s";' %
-                  type_.unix_name)
-      .Append('return result.Pass();')
-      .Eblock('}')
-    )
-    return c
-
-  def _GenerateFunction(self, function):
-    """Generates the definitions for function structs.
-    """
-    c = Code()
-
-    # TODO(kalman): use function.unix_name not Classname.
-    function_namespace = cpp_util.Classname(function.name)
-    # Windows has a #define for SendMessage, so to avoid any issues, we need
-    # to not use the name.
-    if function_namespace == 'SendMessage':
-      function_namespace = 'PassMessage'
-    (c.Append('namespace %s {' % function_namespace)
-      .Append()
-    )
-
-    # Params::Populate function
-    if function.params:
-      c.Concat(self._GeneratePropertyFunctions('Params', function.params))
-      (c.Append('Params::Params() {}')
-        .Append('Params::~Params() {}')
-        .Append()
-        .Cblock(self._GenerateFunctionParamsCreate(function))
-      )
-
-    # Results::Create function
-    if function.callback:
-      c.Concat(self._GenerateCreateCallbackArguments(function_namespace,
-                                                     'Results',
-                                                     function.callback))
-
-    c.Append('}  // namespace %s' % function_namespace)
-    return c
-
-  def _GenerateEvent(self, event):
-    # TODO(kalman): use event.unix_name not Classname.
-    c = Code()
-    event_namespace = cpp_util.Classname(event.name)
-    (c.Append('namespace %s {' % event_namespace)
-      .Append()
-      .Cblock(self._GenerateEventNameConstant(None, event))
-      .Cblock(self._GenerateCreateCallbackArguments(event_namespace,
-                                                    None,
-                                                    event))
-      .Append('}  // namespace %s' % event_namespace)
-    )
-    return c
-
-  def _CreateValueFromType(self, code, prop_name, type_, var, is_ptr=False):
-    """Creates a base::Value given a type. Generated code passes ownership
-    to caller.
-
-    var: variable or variable*
-
-    E.g for std::string, generate new base::StringValue(var)
-    """
-    c = Code()
-    underlying_type = self._type_helper.FollowRef(type_)
-    if underlying_type.property_type == PropertyType.ARRAY:
-      # Enums are treated specially because C++ templating thinks that they're
-      # ints, but really they're strings. So we create a vector of strings and
-      # populate it with the names of the enum in the array. The |ToString|
-      # function of the enum can be in another namespace when the enum is
-      # referenced. Templates can not be used here because C++ templating does
-      # not support passing a namespace as an argument.
-      item_type = self._type_helper.FollowRef(underlying_type.item_type)
-      if item_type.property_type == PropertyType.ENUM:
-        vardot = '(%s)%s' % (var, '->' if is_ptr else '.')
-
-        maybe_namespace = ''
-        if type_.item_type.property_type == PropertyType.REF:
-          maybe_namespace = '%s::' % item_type.namespace.unix_name
-
-        enum_list_var = '%s_list' % prop_name
-        # Scope the std::vector variable declaration inside braces.
-        (c.Sblock('{')
-          .Append('std::vector<std::string> %s;' % enum_list_var)
-          .Append('for (std::vector<%s>::const_iterator it = %sbegin();'
-              % (self._type_helper.GetCppType(item_type), vardot))
-          .Sblock('    it != %send(); ++it) {' % vardot)
-          .Append('%s.push_back(%sToString(*it));' % (enum_list_var,
-                                                      maybe_namespace))
-          .Eblock('}'))
-
-        # Because the std::vector above is always created for both required and
-        # optional enum arrays, |is_ptr| is set to false and uses the
-        # std::vector to create the values.
-        (c.Append(code %
-            self._GenerateCreateValueFromType(type_, enum_list_var, False))
-          .Eblock('}'))
-        return c
-
-    c.Append(code % self._GenerateCreateValueFromType(type_, var, is_ptr))
-    return c
-
-  def _GenerateCreateValueFromType(self, type_, var, is_ptr):
-    """Generates the statement to create a base::Value given a type.
-
-    type_:  The type of the values being converted.
-    var:    The name of the variable.
-    is_ptr: Whether |type_| is optional.
-    """
-    underlying_type = self._type_helper.FollowRef(type_)
-    if (underlying_type.property_type == PropertyType.CHOICES or
-        underlying_type.property_type == PropertyType.OBJECT):
-      if is_ptr:
-        return '(%s)->ToValue().release()' % var
-      else:
-        return '(%s).ToValue().release()' % var
-    elif (underlying_type.property_type == PropertyType.ANY or
-          underlying_type.property_type == PropertyType.FUNCTION):
-      if is_ptr:
-        vardot = '(%s)->' % var
-      else:
-        vardot = '(%s).' % var
-      return '%sDeepCopy()' % vardot
-    elif underlying_type.property_type == PropertyType.ENUM:
-      maybe_namespace = ''
-      if type_.property_type == PropertyType.REF:
-        maybe_namespace = '%s::' % underlying_type.namespace.unix_name
-      return 'new base::StringValue(%sToString(%s))' % (maybe_namespace, var)
-    elif underlying_type.property_type == PropertyType.BINARY:
-      if is_ptr:
-        vardot = var + '->'
-      else:
-        vardot = var + '.'
-      return ('base::BinaryValue::CreateWithCopiedBuffer(%sdata(), %ssize())' %
-              (vardot, vardot))
-    elif underlying_type.property_type == PropertyType.ARRAY:
-      return '%s.release()' % self._util_cc_helper.CreateValueFromArray(
-          var,
-          is_ptr)
-    elif underlying_type.property_type.is_fundamental:
-      if is_ptr:
-        var = '*%s' % var
-      if underlying_type.property_type == PropertyType.STRING:
-        return 'new base::StringValue(%s)' % var
-      else:
-        return 'new base::FundamentalValue(%s)' % var
-    else:
-      raise NotImplementedError('Conversion of %s to base::Value not '
-                                'implemented' % repr(type_.type_))
-
-  def _GenerateParamsCheck(self, function, var):
-    """Generates a check for the correct number of arguments when creating
-    Params.
-    """
-    c = Code()
-    num_required = 0
-    for param in function.params:
-      if not param.optional:
-        num_required += 1
-    if num_required == len(function.params):
-      c.Sblock('if (%(var)s.GetSize() != %(total)d) {')
-    elif not num_required:
-      c.Sblock('if (%(var)s.GetSize() > %(total)d) {')
-    else:
-      c.Sblock('if (%(var)s.GetSize() < %(required)d'
-          ' || %(var)s.GetSize() > %(total)d) {')
-    (c.Concat(self._GenerateError(
-        '"expected %%(total)d arguments, got " '
-        '+ base::IntToString(%%(var)s.GetSize())'))
-      .Append('return scoped_ptr<Params>();')
-      .Eblock('}')
-      .Substitute({
-        'var': var,
-        'required': num_required,
-        'total': len(function.params),
-    }))
-    return c
-
-  def _GenerateFunctionParamsCreate(self, function):
-    """Generate function to create an instance of Params. The generated
-    function takes a base::ListValue of arguments.
-
-    E.g for function "Bar", generate Bar::Params::Create()
-    """
-    c = Code()
-    (c.Append('// static')
-      .Sblock('scoped_ptr<Params> Params::Create(%s) {' % self._GenerateParams(
-        ['const base::ListValue& args']))
-    )
-    if self._generate_error_messages:
-      c.Append('DCHECK(error);')
-    (c.Concat(self._GenerateParamsCheck(function, 'args'))
-      .Append('scoped_ptr<Params> params(new Params());')
-    )
-
-    for param in function.params:
-      c.Concat(self._InitializePropertyToDefault(param, 'params'))
-
-    for i, param in enumerate(function.params):
-      # Any failure will cause this function to return. If any argument is
-      # incorrect or missing, those following it are not processed. Note that
-      # for optional arguments, we allow missing arguments and proceed because
-      # there may be other arguments following it.
-      failure_value = 'scoped_ptr<Params>()'
-      c.Append()
-      value_var = param.unix_name + '_value'
-      (c.Append('const base::Value* %(value_var)s = NULL;')
-        .Append('if (args.Get(%(i)s, &%(value_var)s) &&')
-        .Sblock('    !%(value_var)s->IsType(base::Value::TYPE_NULL)) {')
-        .Concat(self._GeneratePopulatePropertyFromValue(
-            param, value_var, 'params', failure_value))
-        .Eblock('}')
-      )
-      if not param.optional:
-        (c.Sblock('else {')
-          .Concat(self._GenerateError('"\'%%(key)s\' is required"'))
-          .Append('return %s;' % failure_value)
-          .Eblock('}'))
-      c.Substitute({'value_var': value_var, 'i': i, 'key': param.name})
-    (c.Append()
-      .Append('return params.Pass();')
-      .Eblock('}')
-      .Append()
-    )
-
-    return c
-
-  def _GeneratePopulatePropertyFromValue(self,
-                                         prop,
-                                         src_var,
-                                         dst_class_var,
-                                         failure_value):
-    """Generates code to populate property |prop| of |dst_class_var| (a
-    pointer) from a Value*. See |_GeneratePopulateVariableFromValue| for
-    semantics.
-    """
-    return self._GeneratePopulateVariableFromValue(prop.type_,
-                                                   src_var,
-                                                   '%s->%s' % (dst_class_var,
-                                                               prop.unix_name),
-                                                   failure_value,
-                                                   is_ptr=prop.optional)
-
-  def _GeneratePopulateVariableFromValue(self,
-                                         type_,
-                                         src_var,
-                                         dst_var,
-                                         failure_value,
-                                         is_ptr=False):
-    """Generates code to populate a variable |dst_var| of type |type_| from a
-    Value* at |src_var|. The Value* is assumed to be non-NULL. In the generated
-    code, if |dst_var| fails to be populated then Populate will return
-    |failure_value|.
-    """
-    c = Code()
-
-    underlying_type = self._type_helper.FollowRef(type_)
-
-    if underlying_type.property_type.is_fundamental:
-      if is_ptr:
-        (c.Append('%(cpp_type)s temp;')
-          .Sblock('if (!%s) {' % cpp_util.GetAsFundamentalValue(
-                      self._type_helper.FollowRef(type_), src_var, '&temp'))
-          .Concat(self._GenerateError(
-            '"\'%%(key)s\': expected ' + '%s, got " + %s' % (
-                type_.name,
-                self._util_cc_helper.GetValueTypeString(
-                    '%%(src_var)s', True)))))
-        c.Append('%(dst_var)s.reset();')
-        if not self._generate_error_messages:
-          c.Append('return %(failure_value)s;')
-        (c.Eblock('}')
-          .Append('else')
-          .Append('  %(dst_var)s.reset(new %(cpp_type)s(temp));')
-        )
-      else:
-        (c.Sblock('if (!%s) {' % cpp_util.GetAsFundamentalValue(
-                      self._type_helper.FollowRef(type_),
-                      src_var,
-                      '&%s' % dst_var))
-          .Concat(self._GenerateError(
-            '"\'%%(key)s\': expected ' + '%s, got " + %s' % (
-                type_.name,
-                self._util_cc_helper.GetValueTypeString(
-                    '%%(src_var)s', True))))
-          .Append('return %(failure_value)s;')
-          .Eblock('}')
-        )
-    elif underlying_type.property_type == PropertyType.OBJECT:
-      if is_ptr:
-        (c.Append('const base::DictionaryValue* dictionary = NULL;')
-          .Sblock('if (!%(src_var)s->GetAsDictionary(&dictionary)) {')
-          .Concat(self._GenerateError(
-            '"\'%%(key)s\': expected dictionary, got " + ' +
-            self._util_cc_helper.GetValueTypeString('%%(src_var)s', True))))
-        # If an optional property fails to populate, the population can still
-        # succeed with a warning. If no error messages are generated, this
-        # warning is not set and we fail out instead.
-        if not self._generate_error_messages:
-          c.Append('return %(failure_value)s;')
-        (c.Eblock('}')
-          .Sblock('else {')
-          .Append('scoped_ptr<%(cpp_type)s> temp(new %(cpp_type)s());')
-          .Append('if (!%%(cpp_type)s::Populate(%s)) {' % self._GenerateArgs(
-            ('*dictionary', 'temp.get()')))
-          .Append('  return %(failure_value)s;')
-        )
-        (c.Append('}')
-          .Append('else')
-          .Append('  %(dst_var)s = temp.Pass();')
-          .Eblock('}')
-        )
-      else:
-        (c.Append('const base::DictionaryValue* dictionary = NULL;')
-          .Sblock('if (!%(src_var)s->GetAsDictionary(&dictionary)) {')
-          .Concat(self._GenerateError(
-            '"\'%%(key)s\': expected dictionary, got " + ' +
-            self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
-          .Append('return %(failure_value)s;')
-          .Eblock('}')
-          .Append('if (!%%(cpp_type)s::Populate(%s)) {' % self._GenerateArgs(
-            ('*dictionary', '&%(dst_var)s')))
-          .Append('  return %(failure_value)s;')
-          .Append('}')
-        )
-    elif underlying_type.property_type == PropertyType.FUNCTION:
-      if is_ptr:
-        c.Append('%(dst_var)s.reset(new base::DictionaryValue());')
-    elif underlying_type.property_type == PropertyType.ANY:
-      c.Append('%(dst_var)s.reset(%(src_var)s->DeepCopy());')
-    elif underlying_type.property_type == PropertyType.ARRAY:
-      # util_cc_helper deals with optional and required arrays
-      (c.Append('const base::ListValue* list = NULL;')
-        .Sblock('if (!%(src_var)s->GetAsList(&list)) {')
-          .Concat(self._GenerateError(
-            '"\'%%(key)s\': expected list, got " + ' +
-            self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
-      )
-      if is_ptr and self._generate_error_messages:
-        c.Append('%(dst_var)s.reset();')
-      else:
-        c.Append('return %(failure_value)s;')
-      c.Eblock('}')
-      c.Sblock('else {')
-      item_type = self._type_helper.FollowRef(underlying_type.item_type)
-      if item_type.property_type == PropertyType.ENUM:
-        c.Concat(self._GenerateListValueToEnumArrayConversion(
-                     item_type,
-                     'list',
-                     dst_var,
-                     failure_value,
-                     is_ptr=is_ptr))
-      else:
-        (c.Sblock('if (!%s) {' % self._util_cc_helper.PopulateArrayFromList(
-              'list',
-              dst_var,
-              is_ptr)))
-        c.Concat(self._GenerateError(
-            '"unable to populate array \'%%(parent_key)s\'"'))
-        if is_ptr and self._generate_error_messages:
-          c.Append('%(dst_var)s.reset();')
-        else:
-          c.Append('return %(failure_value)s;')
-        c.Eblock('}')
-      c.Eblock('}')
-    elif underlying_type.property_type == PropertyType.CHOICES:
-      if is_ptr:
-        (c.Append('scoped_ptr<%(cpp_type)s> temp(new %(cpp_type)s());')
-          .Append('if (!%%(cpp_type)s::Populate(%s))' % self._GenerateArgs(
-            ('*%(src_var)s', 'temp.get()')))
-          .Append('  return %(failure_value)s;')
-          .Append('%(dst_var)s = temp.Pass();')
-        )
-      else:
-        (c.Append('if (!%%(cpp_type)s::Populate(%s))' % self._GenerateArgs(
-            ('*%(src_var)s', '&%(dst_var)s')))
-          .Append('  return %(failure_value)s;'))
-    elif underlying_type.property_type == PropertyType.ENUM:
-      c.Concat(self._GenerateStringToEnumConversion(underlying_type,
-                                                    src_var,
-                                                    dst_var,
-                                                    failure_value))
-    elif underlying_type.property_type == PropertyType.BINARY:
-      (c.Append('const base::BinaryValue* binary_value = NULL;')
-        .Sblock('if (!%(src_var)s->IsType(base::Value::TYPE_BINARY)) {')
-        .Concat(self._GenerateError(
-          '"\'%%(key)s\': expected binary, got " + ' +
-          self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
-      )
-      if not self._generate_error_messages:
-        c.Append('return %(failure_value)s;')
-      (c.Eblock('}')
-        .Sblock('else {')
-        .Append(' binary_value =')
-        .Append('   static_cast<const base::BinaryValue*>(%(src_var)s);')
-      )
-      if is_ptr:
-        (c.Append('%(dst_var)s.reset(')
-          .Append('    new std::string(binary_value->GetBuffer(),')
-          .Append('                    binary_value->GetSize()));')
-        )
-      else:
-        (c.Append('%(dst_var)s.assign(binary_value->GetBuffer(),')
-          .Append('                   binary_value->GetSize());')
-        )
-      c.Eblock('}')
-    else:
-      raise NotImplementedError(type_)
-    if c.IsEmpty():
-      return c
-    return Code().Sblock('{').Concat(c.Substitute({
-      'cpp_type': self._type_helper.GetCppType(type_),
-      'src_var': src_var,
-      'dst_var': dst_var,
-      'failure_value': failure_value,
-      'key': type_.name,
-      'parent_key': type_.parent.name,
-    })).Eblock('}')
-
-  def _GenerateListValueToEnumArrayConversion(self,
-                                              item_type,
-                                              src_var,
-                                              dst_var,
-                                              failure_value,
-                                              is_ptr=False):
-    """Returns Code that converts a ListValue of string constants from
-    |src_var| into an array of enums of |type_| in |dst_var|. On failure,
-    returns |failure_value|.
-    """
-    c = Code()
-    accessor = '.'
-    if is_ptr:
-      accessor = '->'
-      cpp_type = self._type_helper.GetCppType(item_type, is_in_container=True)
-      c.Append('%s.reset(new std::vector<%s>);' %
-                   (dst_var, cpp_util.PadForGenerics(cpp_type)))
-    (c.Sblock('for (base::ListValue::const_iterator it = %s->begin(); '
-                   'it != %s->end(); ++it) {' % (src_var, src_var))
-      .Append('%s tmp;' % self._type_helper.GetCppType(item_type))
-      .Concat(self._GenerateStringToEnumConversion(item_type,
-                                                   '(*it)',
-                                                   'tmp',
-                                                   failure_value))
-      .Append('%s%spush_back(tmp);' % (dst_var, accessor))
-      .Eblock('}')
-    )
-    return c
-
-  def _GenerateStringToEnumConversion(self,
-                                      type_,
-                                      src_var,
-                                      dst_var,
-                                      failure_value):
-    """Returns Code that converts a string type in |src_var| to an enum with
-    type |type_| in |dst_var|. In the generated code, if |src_var| is not
-    a valid enum name then the function will return |failure_value|.
-    """
-    if type_.property_type != PropertyType.ENUM:
-      raise TypeError(type_)
-    c = Code()
-    enum_as_string = '%s_as_string' % type_.unix_name
-    cpp_type_namespace = ''
-    if type_.namespace != self._namespace:
-      cpp_type_namespace = '%s::' % type_.namespace.unix_name
-    cpp_type_name = self._type_helper.GetCppType(type_)
-    (c.Append('std::string %s;' % enum_as_string)
-      .Sblock('if (!%s->GetAsString(&%s)) {' % (src_var, enum_as_string))
-      .Concat(self._GenerateError(
-        '"\'%%(key)s\': expected string, got " + ' +
-        self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
-      .Append('return %s;' % failure_value)
-      .Eblock('}')
-      .Append('%s = %sParse%s(%s);' % (dst_var,
-                                       cpp_type_namespace,
-                                       cpp_util.Classname(type_.name),
-                                       enum_as_string))
-      .Sblock('if (%s == %s%s) {' % (dst_var,
-                                     cpp_type_namespace,
-                                     self._type_helper.GetEnumNoneValue(type_)))
-      .Concat(self._GenerateError(
-        '\"\'%%(key)s\': expected \\"' +
-        '\\" or \\"'.join(
-            enum_value.name
-            for enum_value in self._type_helper.FollowRef(type_).enum_values) +
-        '\\", got \\"" + %s + "\\""' % enum_as_string))
-      .Append('return %s;' % failure_value)
-      .Eblock('}')
-      .Substitute({'src_var': src_var, 'key': type_.name})
-    )
-    return c
-
-  def _GeneratePropertyFunctions(self, namespace, params):
-    """Generates the member functions for a list of parameters.
-    """
-    return self._GenerateTypes(namespace, (param.type_ for param in params))
-
-  def _GenerateTypes(self, namespace, types):
-    """Generates the member functions for a list of types.
-    """
-    c = Code()
-    for type_ in types:
-      c.Cblock(self._GenerateType(namespace, type_))
-    return c
-
-  def _GenerateEnumToString(self, cpp_namespace, type_):
-    """Generates ToString() which gets the string representation of an enum.
-    """
-    c = Code()
-    classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
-
-    if cpp_namespace is not None:
-      c.Append('// static')
-    maybe_namespace = '' if cpp_namespace is None else '%s::' % cpp_namespace
-
-    c.Sblock('std::string %sToString(%s enum_param) {' %
-                 (maybe_namespace, classname))
-    c.Sblock('switch (enum_param) {')
-    for enum_value in self._type_helper.FollowRef(type_).enum_values:
-      name = enum_value.name
-      if 'camel_case_enum_to_string' in self._namespace.compiler_options:
-        name = enum_value.CamelName()
-      (c.Append('case %s: ' % self._type_helper.GetEnumValue(type_, enum_value))
-        .Append('  return "%s";' % name))
-    (c.Append('case %s:' % self._type_helper.GetEnumNoneValue(type_))
-      .Append('  return "";')
-      .Eblock('}')
-      .Append('NOTREACHED();')
-      .Append('return "";')
-      .Eblock('}')
-    )
-    return c
-
-  def _GenerateEnumFromString(self, cpp_namespace, type_):
-    """Generates FromClassNameString() which gets an enum from its string
-    representation.
-    """
-    c = Code()
-    classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
-
-    if cpp_namespace is not None:
-      c.Append('// static')
-    maybe_namespace = '' if cpp_namespace is None else '%s::' % cpp_namespace
-
-    c.Sblock('%s%s %sParse%s(const std::string& enum_string) {' %
-                 (maybe_namespace, classname, maybe_namespace, classname))
-    for i, enum_value in enumerate(
-          self._type_helper.FollowRef(type_).enum_values):
-      # This is broken up into all ifs with no else ifs because we get
-      # "fatal error C1061: compiler limit : blocks nested too deeply"
-      # on Windows.
-      (c.Append('if (enum_string == "%s")' % enum_value.name)
-        .Append('  return %s;' %
-            self._type_helper.GetEnumValue(type_, enum_value)))
-    (c.Append('return %s;' % self._type_helper.GetEnumNoneValue(type_))
-      .Eblock('}')
-    )
-    return c
-
-  def _GenerateCreateCallbackArguments(self,
-                                       cpp_namespace,
-                                       function_scope,
-                                       callback):
-    """Generate all functions to create Value parameters for a callback.
-
-    E.g for function "Bar", generate Bar::Results::Create
-    E.g for event "Baz", generate Baz::Create
-
-    function_scope: the function scope path, e.g. Foo::Bar for the function
-                    Foo::Bar::Baz(). May be None if there is no function scope.
-    callback: the Function object we are creating callback arguments for.
-    """
-    c = Code()
-    params = callback.params
-    c.Concat(self._GeneratePropertyFunctions(function_scope, params))
-
-    (c.Sblock('scoped_ptr<base::ListValue> %(function_scope)s'
-                  'Create(%(declaration_list)s) {')
-      .Append('scoped_ptr<base::ListValue> create_results('
-              'new base::ListValue());')
-    )
-    declaration_list = []
-    for param in params:
-      declaration_list.append(cpp_util.GetParameterDeclaration(
-          param, self._type_helper.GetCppType(param.type_)))
-      c.Cblock(self._CreateValueFromType('create_results->Append(%s);',
-                                         param.name,
-                                         param.type_,
-                                         param.unix_name))
-    c.Append('return create_results.Pass();')
-    c.Eblock('}')
-    c.Substitute({
-        'function_scope': ('%s::' % function_scope) if function_scope else '',
-        'declaration_list': ', '.join(declaration_list),
-        'param_names': ', '.join(param.unix_name for param in params)
-    })
-    return c
-
-  def _GenerateEventNameConstant(self, function_scope, event):
-    """Generates a constant string array for the event name.
-    """
-    c = Code()
-    c.Append('const char kEventName[] = "%s.%s";' % (
-                 self._namespace.name, event.name))
-    return c
-
-  def _InitializePropertyToDefault(self, prop, dst):
-    """Initialize a model.Property to its default value inside an object.
-
-    E.g for optional enum "state", generate dst->state = STATE_NONE;
-
-    dst: Type*
-    """
-    c = Code()
-    underlying_type = self._type_helper.FollowRef(prop.type_)
-    if (underlying_type.property_type == PropertyType.ENUM and
-        prop.optional):
-      c.Append('%s->%s = %s;' % (
-        dst,
-        prop.unix_name,
-        self._type_helper.GetEnumNoneValue(prop.type_)))
-    return c
-
-  def _GenerateError(self, body):
-    """Generates an error message pertaining to population failure.
-
-    E.g 'expected bool, got int'
-    """
-    c = Code()
-    if not self._generate_error_messages:
-      return c
-    (c.Append('if (error->length())')
-      .Append('  error->append(UTF8ToUTF16("; "));')
-      .Append('error->append(UTF8ToUTF16(%s));' % body))
-    return c
-
-  def _GenerateParams(self, params):
-    """Builds the parameter list for a function, given an array of parameters.
-    """
-    if self._generate_error_messages:
-      params = list(params) + ['base::string16* error']
-    return ', '.join(str(p) for p in params)
-
-  def _GenerateArgs(self, args):
-    """Builds the argument list for a function, given an array of arguments.
-    """
-    if self._generate_error_messages:
-      args = list(args) + ['error']
-    return ', '.join(str(a) for a in args)
diff --git a/tools/json_schema_compiler/code.py b/tools/json_schema_compiler/code.py
deleted file mode 100644
index 8ce6afa..0000000
--- a/tools/json_schema_compiler/code.py
+++ /dev/null
@@ -1,142 +0,0 @@
-# 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.
-
-class Code(object):
-  """A convenience object for constructing code.
-
-  Logically each object should be a block of code. All methods except |Render|
-  and |IsEmpty| return self.
-  """
-  def __init__(self, indent_size=2, comment_length=80):
-    self._code = []
-    self._indent_level = 0
-    self._indent_size = indent_size
-    self._comment_length = comment_length
-
-  def Append(self, line='', substitute=True, indent_level=None):
-    """Appends a line of code at the current indent level or just a newline if
-    line is not specified. Trailing whitespace is stripped.
-
-    substitute: indicated whether this line should be affected by
-    code.Substitute().
-    """
-    if indent_level is None:
-      indent_level = self._indent_level
-    self._code.append(Line(((' ' * indent_level) + line).rstrip(),
-                      substitute=substitute))
-    return self
-
-  def IsEmpty(self):
-    """Returns True if the Code object is empty.
-    """
-    return not bool(self._code)
-
-  def Concat(self, obj):
-    """Concatenate another Code object onto this one. Trailing whitespace is
-    stripped.
-
-    Appends the code at the current indent level. Will fail if there are any
-    un-interpolated format specifiers eg %s, %(something)s which helps
-    isolate any strings that haven't been substituted.
-    """
-    if not isinstance(obj, Code):
-      raise TypeError(type(obj))
-    assert self is not obj
-    for line in obj._code:
-      try:
-        # line % () will fail if any substitution tokens are left in line
-        if line.substitute:
-          line.value %= ()
-      except TypeError:
-        raise TypeError('Unsubstituted value when concatting\n' + line.value)
-      except ValueError:
-        raise ValueError('Stray % character when concatting\n' + line.value)
-      self.Append(line.value, line.substitute)
-
-    return self
-
-  def Cblock(self, code):
-    """Concatenates another Code object |code| onto this one followed by a
-    blank line, if |code| is non-empty."""
-    if not code.IsEmpty():
-      self.Concat(code).Append()
-    return self
-
-  def Sblock(self, line=None):
-    """Starts a code block.
-
-    Appends a line of code and then increases the indent level.
-    """
-    if line is not None:
-      self.Append(line)
-    self._indent_level += self._indent_size
-    return self
-
-  def Eblock(self, line=None):
-    """Ends a code block by decreasing and then appending a line (or a blank
-    line if not given).
-    """
-    # TODO(calamity): Decide if type checking is necessary
-    #if not isinstance(line, basestring):
-    #  raise TypeError
-    self._indent_level -= self._indent_size
-    if line is not None:
-      self.Append(line)
-    return self
-
-  def Comment(self, comment, comment_prefix='// '):
-    """Adds the given string as a comment.
-
-    Will split the comment if it's too long. Use mainly for variable length
-    comments. Otherwise just use code.Append('// ...') for comments.
-
-    Unaffected by code.Substitute().
-    """
-    max_len = self._comment_length - self._indent_level - len(comment_prefix)
-    while len(comment) >= max_len:
-      line = comment[0:max_len]
-      last_space = line.rfind(' ')
-      if last_space != -1:
-        line = line[0:last_space]
-        comment = comment[last_space + 1:]
-      else:
-        comment = comment[max_len:]
-      self.Append(comment_prefix + line, substitute=False)
-    self.Append(comment_prefix + comment, substitute=False)
-    return self
-
-  def Substitute(self, d):
-    """Goes through each line and interpolates using the given dict.
-
-    Raises type error if passed something that isn't a dict
-
-    Use for long pieces of code using interpolation with the same variables
-    repeatedly. This will reduce code and allow for named placeholders which
-    are more clear.
-    """
-    if not isinstance(d, dict):
-      raise TypeError('Passed argument is not a dictionary: ' + d)
-    for i, line in enumerate(self._code):
-      if self._code[i].substitute:
-        # Only need to check %s because arg is a dict and python will allow
-        # '%s %(named)s' but just about nothing else
-        if '%s' in self._code[i].value or '%r' in self._code[i].value:
-          raise TypeError('"%s" or "%r" found in substitution. '
-                          'Named arguments only. Use "%" to escape')
-        self._code[i].value = line.value % d
-        self._code[i].substitute = False
-    return self
-
-  def Render(self):
-    """Renders Code as a string.
-    """
-    return '\n'.join([l.value for l in self._code])
-
-
-class Line(object):
-  """A line of code.
-  """
-  def __init__(self, value, substitute=True):
-    self.value = value
-    self.substitute = substitute
diff --git a/tools/json_schema_compiler/code_test.py b/tools/json_schema_compiler/code_test.py
deleted file mode 100755
index ca36524..0000000
--- a/tools/json_schema_compiler/code_test.py
+++ /dev/null
@@ -1,165 +0,0 @@
-#!/usr/bin/env python
-# 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.
-
-from code import Code
-import unittest
-
-class CodeTest(unittest.TestCase):
-  def testAppend(self):
-    c = Code()
-    c.Append('line')
-    self.assertEquals('line', c.Render())
-
-  def testBlock(self):
-    c = Code()
-    (c.Append('line')
-      .Sblock('sblock')
-        .Append('inner')
-        .Append('moreinner')
-        .Sblock('moresblock')
-          .Append('inner')
-        .Eblock('out')
-        .Append('inner')
-      .Eblock('out')
-    )
-    self.assertEquals(
-      'line\n'
-      'sblock\n'
-      '  inner\n'
-      '  moreinner\n'
-      '  moresblock\n'
-      '    inner\n'
-      '  out\n'
-      '  inner\n'
-      'out',
-      c.Render())
-
-  def testConcat(self):
-    b = Code()
-    (b.Sblock('2')
-        .Append('2')
-      .Eblock('2')
-    )
-    c = Code()
-    (c.Sblock('1')
-        .Concat(b)
-        .Append('1')
-      .Eblock('1')
-    )
-    self.assertEquals(
-      '1\n'
-      '  2\n'
-      '    2\n'
-      '  2\n'
-      '  1\n'
-      '1',
-      c.Render())
-    d = Code()
-    a = Code()
-    a.Concat(d)
-    self.assertEquals('', a.Render())
-    a.Concat(c)
-    self.assertEquals(
-      '1\n'
-      '  2\n'
-      '    2\n'
-      '  2\n'
-      '  1\n'
-      '1',
-      a.Render())
-
-  def testConcatErrors(self):
-    c = Code()
-    d = Code()
-    d.Append('%s')
-    self.assertRaises(TypeError, c.Concat, d)
-    d = Code()
-    d.Append('%(classname)s')
-    self.assertRaises(TypeError, c.Concat, d)
-    d = 'line of code'
-    self.assertRaises(TypeError, c.Concat, d)
-
-  def testSubstitute(self):
-    c = Code()
-    c.Append('%(var1)s %(var2)s %(var1)s')
-    c.Substitute({'var1': 'one', 'var2': 'two'})
-    self.assertEquals('one two one', c.Render())
-    c.Append('%(var1)s %(var2)s %(var3)s')
-    c.Append('%(var2)s %(var1)s %(var3)s')
-    c.Substitute({'var1': 'one', 'var2': 'two', 'var3': 'three'})
-    self.assertEquals(
-        'one two one\n'
-        'one two three\n'
-        'two one three',
-        c.Render())
-
-  def testSubstituteErrors(self):
-    # No unnamed placeholders allowed when substitute is run
-    c = Code()
-    c.Append('%s %s')
-    self.assertRaises(TypeError, c.Substitute, ('var1', 'one'))
-    c = Code()
-    c.Append('%s %(var1)s')
-    self.assertRaises(TypeError, c.Substitute, {'var1': 'one'})
-    c = Code()
-    c.Append('%s %(var1)s')
-    self.assertRaises(TypeError, c.Substitute, {'var1': 'one'})
-    c = Code()
-    c.Append('%(var1)s')
-    self.assertRaises(KeyError, c.Substitute, {'clearlynotvar1': 'one'})
-
-  def testIsEmpty(self):
-    c = Code()
-    self.assertTrue(c.IsEmpty())
-    c.Append('asdf')
-    self.assertFalse(c.IsEmpty())
-
-  def testComment(self):
-    long_comment = ('This comment is eighty nine characters in longness, '
-        'that is, to use another word, length')
-    c = Code()
-    c.Comment(long_comment)
-    self.assertEquals(
-        '// This comment is eighty nine characters '
-        'in longness, that is, to use another\n'
-        '// word, length',
-        c.Render())
-    c = Code()
-    c.Sblock('sblock')
-    c.Comment(long_comment)
-    c.Eblock('eblock')
-    c.Comment(long_comment)
-    self.assertEquals(
-        'sblock\n'
-        '  // This comment is eighty nine characters '
-        'in longness, that is, to use\n'
-        '  // another word, length\n'
-        'eblock\n'
-        '// This comment is eighty nine characters in '
-        'longness, that is, to use another\n'
-        '// word, length',
-        c.Render())
-    long_word = 'x' * 100
-    c = Code()
-    c.Comment(long_word)
-    self.assertEquals(
-        '// ' + 'x' * 77 + '\n'
-        '// ' + 'x' * 23,
-        c.Render())
-
-  def testCommentWithSpecialCharacters(self):
-    c = Code()
-    c.Comment('20% of 80%s')
-    c.Substitute({})
-    self.assertEquals('// 20% of 80%s', c.Render())
-    d = Code()
-    d.Append('90')
-    d.Concat(c)
-    self.assertEquals('90\n'
-        '// 20% of 80%s',
-        d.Render())
-
-if __name__ == '__main__':
-  unittest.main()
diff --git a/tools/json_schema_compiler/compiler.py b/tools/json_schema_compiler/compiler.py
deleted file mode 100755
index 7a2e4dd..0000000
--- a/tools/json_schema_compiler/compiler.py
+++ /dev/null
@@ -1,198 +0,0 @@
-#!/usr/bin/env python
-# 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.
-"""Generator for C++ structs from api json files.
-
-The purpose of this tool is to remove the need for hand-written code that
-converts to and from base::Value types when receiving javascript api calls.
-Originally written for generating code for extension apis. Reference schemas
-are in chrome/common/extensions/api.
-
-Usage example:
-  compiler.py --root /home/Work/src --namespace extensions windows.json
-    tabs.json
-  compiler.py --destdir gen --root /home/Work/src
-    --namespace extensions windows.json tabs.json
-"""
-
-import optparse
-import os
-import shlex
-import sys
-
-from cpp_bundle_generator import CppBundleGenerator
-from cpp_generator import CppGenerator
-from cpp_type_generator import CppTypeGenerator
-from dart_generator import DartGenerator
-import json_schema
-from cpp_namespace_environment import CppNamespaceEnvironment
-from model import Model
-from schema_loader import SchemaLoader
-
-# Names of supported code generators, as specified on the command-line.
-# First is default.
-GENERATORS = ['cpp', 'cpp-bundle-registration', 'cpp-bundle-schema', 'dart']
-
-def GenerateSchema(generator_name,
-                   file_paths,
-                   root,
-                   destdir,
-                   cpp_namespace_pattern,
-                   dart_overrides_dir,
-                   impl_dir,
-                   include_rules):
-  # Merge the source files into a single list of schemas.
-  api_defs = []
-  for file_path in file_paths:
-    schema = os.path.relpath(file_path, root)
-    schema_loader = SchemaLoader(
-        root,
-        os.path.dirname(schema),
-        include_rules,
-        cpp_namespace_pattern)
-    api_def = schema_loader.LoadSchema(schema)
-
-    # If compiling the C++ model code, delete 'nocompile' nodes.
-    if generator_name == 'cpp':
-      api_def = json_schema.DeleteNodes(api_def, 'nocompile')
-    api_defs.extend(api_def)
-
-  api_model = Model()
-
-  # For single-schema compilation make sure that the first (i.e. only) schema
-  # is the default one.
-  default_namespace = None
-
-  # If we have files from multiple source paths, we'll use the common parent
-  # path as the source directory.
-  src_path = None
-
-  # Load the actual namespaces into the model.
-  for target_namespace, file_path in zip(api_defs, file_paths):
-    relpath = os.path.relpath(os.path.normpath(file_path), root)
-    namespace = api_model.AddNamespace(target_namespace,
-                                       relpath,
-                                       include_compiler_options=True,
-                                       environment=CppNamespaceEnvironment(
-                                           cpp_namespace_pattern))
-
-    if default_namespace is None:
-      default_namespace = namespace
-
-    if src_path is None:
-      src_path = namespace.source_file_dir
-    else:
-      src_path = os.path.commonprefix((src_path, namespace.source_file_dir))
-
-    path, filename = os.path.split(file_path)
-    filename_base, _ = os.path.splitext(filename)
-
-  # Construct the type generator with all the namespaces in this model.
-  type_generator = CppTypeGenerator(api_model,
-                                    schema_loader,
-                                    default_namespace)
-  if generator_name in ('cpp-bundle-registration', 'cpp-bundle-schema'):
-    cpp_bundle_generator = CppBundleGenerator(root,
-                                              api_model,
-                                              api_defs,
-                                              type_generator,
-                                              cpp_namespace_pattern,
-                                              src_path,
-                                              impl_dir)
-    if generator_name == 'cpp-bundle-registration':
-      generators = [
-        ('generated_api_registration.cc',
-         cpp_bundle_generator.api_cc_generator),
-        ('generated_api_registration.h', cpp_bundle_generator.api_h_generator),
-      ]
-    elif generator_name == 'cpp-bundle-schema':
-      generators = [
-        ('generated_schemas.cc', cpp_bundle_generator.schemas_cc_generator),
-        ('generated_schemas.h', cpp_bundle_generator.schemas_h_generator)
-      ]
-  elif generator_name == 'cpp':
-    cpp_generator = CppGenerator(type_generator)
-    generators = [
-      ('%s.h' % filename_base, cpp_generator.h_generator),
-      ('%s.cc' % filename_base, cpp_generator.cc_generator)
-    ]
-  elif generator_name == 'dart':
-    generators = [
-      ('%s.dart' % namespace.unix_name, DartGenerator(
-          dart_overrides_dir))
-    ]
-  else:
-    raise Exception('Unrecognised generator %s' % generator)
-
-  output_code = []
-  for filename, generator in generators:
-    code = generator.Generate(namespace).Render()
-    if destdir:
-      if generator_name == 'cpp-bundle-registration':
-        # Function registrations must be output to impl_dir, since they link in
-        # API implementations.
-        output_dir = os.path.join(destdir, impl_dir)
-      else:
-        output_dir = os.path.join(destdir, src_path)
-      if not os.path.exists(output_dir):
-        os.makedirs(output_dir)
-      with open(os.path.join(output_dir, filename), 'w') as f:
-        f.write(code)
-    output_code += [filename, '', code, '']
-
-  return '\n'.join(output_code)
-
-
-if __name__ == '__main__':
-  parser = optparse.OptionParser(
-      description='Generates a C++ model of an API from JSON schema',
-      usage='usage: %prog [option]... schema')
-  parser.add_option('-r', '--root', default='.',
-      help='logical include root directory. Path to schema files from specified'
-      ' dir will be the include path.')
-  parser.add_option('-d', '--destdir',
-      help='root directory to output generated files.')
-  parser.add_option('-n', '--namespace', default='generated_api_schemas',
-      help='C++ namespace for generated files. e.g extensions::api.')
-  parser.add_option('-g', '--generator', default=GENERATORS[0],
-      choices=GENERATORS,
-      help='The generator to use to build the output code. Supported values are'
-      ' %s' % GENERATORS)
-  parser.add_option('-D', '--dart-overrides-dir', dest='dart_overrides_dir',
-      help='Adds custom dart from files in the given directory (Dart only).')
-  parser.add_option('-i', '--impl-dir', dest='impl_dir',
-      help='The root path of all API implementations')
-  parser.add_option('-I', '--include-rules',
-      help='A list of paths to include when searching for referenced objects,'
-      ' with the namespace separated by a \':\'. Example: '
-      '/foo/bar:Foo::Bar::%(namespace)s')
-
-  (opts, file_paths) = parser.parse_args()
-
-  if not file_paths:
-    sys.exit(0) # This is OK as a no-op
-
-  # Unless in bundle mode, only one file should be specified.
-  if (opts.generator not in ('cpp-bundle-registration', 'cpp-bundle-schema') and
-      len(file_paths) > 1):
-    # TODO(sashab): Could also just use file_paths[0] here and not complain.
-    raise Exception(
-        "Unless in bundle mode, only one file can be specified at a time.")
-
-  def split_path_and_namespace(path_and_namespace):
-    if ':' not in path_and_namespace:
-      raise ValueError('Invalid include rule "%s". Rules must be of '
-                       'the form path:namespace' % path_and_namespace)
-    return path_and_namespace.split(':', 1)
-
-  include_rules = []
-  if opts.include_rules:
-    include_rules = map(split_path_and_namespace,
-                        shlex.split(opts.include_rules))
-
-  result = GenerateSchema(opts.generator, file_paths, opts.root, opts.destdir,
-                          opts.namespace, opts.dart_overrides_dir,
-                          opts.impl_dir, include_rules)
-  if not opts.destdir:
-    print result
diff --git a/tools/json_schema_compiler/cpp_bundle_generator.py b/tools/json_schema_compiler/cpp_bundle_generator.py
deleted file mode 100644
index 0a4f9a6..0000000
--- a/tools/json_schema_compiler/cpp_bundle_generator.py
+++ /dev/null
@@ -1,322 +0,0 @@
-# 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.
-
-import code
-import cpp_util
-from model import Platforms
-from schema_util import CapitalizeFirstLetter
-from schema_util import JsFunctionNameToClassName
-
-import json
-import os
-import re
-
-
-def _RemoveDescriptions(node):
-  """Returns a copy of |schema| with "description" fields removed.
-  """
-  if isinstance(node, dict):
-    result = {}
-    for key, value in node.items():
-      # Some schemas actually have properties called "description", so only
-      # remove descriptions that have string values.
-      if key == 'description' and isinstance(value, basestring):
-        continue
-      result[key] = _RemoveDescriptions(value)
-    return result
-  if isinstance(node, list):
-    return [_RemoveDescriptions(v) for v in node]
-  return node
-
-
-class CppBundleGenerator(object):
-  """This class contains methods to generate code based on multiple schemas.
-  """
-
-  def __init__(self,
-               root,
-               model,
-               api_defs,
-               cpp_type_generator,
-               cpp_namespace_pattern,
-               source_file_dir,
-               impl_dir):
-    self._root = root
-    self._model = model
-    self._api_defs = api_defs
-    self._cpp_type_generator = cpp_type_generator
-    self._source_file_dir = source_file_dir
-    self._impl_dir = impl_dir
-
-    # Hack: assume that the C++ namespace for the bundle is the namespace of the
-    # files without the last component of the namespace. A cleaner way to do
-    # this would be to make it a separate variable in the gyp file.
-    self._cpp_namespace = cpp_namespace_pattern.rsplit('::', 1)[0]
-
-    self.api_cc_generator = _APICCGenerator(self)
-    self.api_h_generator = _APIHGenerator(self)
-    self.schemas_cc_generator = _SchemasCCGenerator(self)
-    self.schemas_h_generator = _SchemasHGenerator(self)
-
-  def _GenerateHeader(self, file_base, body_code):
-    """Generates a code.Code object for a header file
-
-    Parameters:
-    - |file_base| - the base of the filename, e.g. 'foo' (for 'foo.h')
-    - |body_code| - the code to put in between the multiple inclusion guards"""
-    c = code.Code()
-    c.Append(cpp_util.CHROMIUM_LICENSE)
-    c.Append()
-    c.Append(cpp_util.GENERATED_BUNDLE_FILE_MESSAGE % self._source_file_dir)
-    ifndef_name = cpp_util.GenerateIfndefName(
-        '%s/%s.h' % (self._source_file_dir, file_base))
-    c.Append()
-    c.Append('#ifndef %s' % ifndef_name)
-    c.Append('#define %s' % ifndef_name)
-    c.Append()
-    c.Concat(body_code)
-    c.Append()
-    c.Append('#endif  // %s' % ifndef_name)
-    c.Append()
-    return c
-
-  def _GetPlatformIfdefs(self, model_object):
-    """Generates the "defined" conditional for an #if check if |model_object|
-    has platform restrictions. Returns None if there are no restrictions.
-    """
-    if model_object.platforms is None:
-      return None
-    ifdefs = []
-    for platform in model_object.platforms:
-      if platform == Platforms.CHROMEOS:
-        ifdefs.append('defined(OS_CHROMEOS)')
-      elif platform == Platforms.LINUX:
-        ifdefs.append('defined(OS_LINUX)')
-      elif platform == Platforms.MAC:
-        ifdefs.append('defined(OS_MACOSX)')
-      elif platform == Platforms.WIN:
-        ifdefs.append('defined(OS_WIN)')
-      else:
-        raise ValueError("Unsupported platform ifdef: %s" % platform.name)
-    return ' || '.join(ifdefs)
-
-  def _GenerateRegisterFunctions(self, namespace_name, function):
-    c = code.Code()
-    function_ifdefs = self._GetPlatformIfdefs(function)
-    if function_ifdefs is not None:
-      c.Append("#if %s" % function_ifdefs, indent_level=0)
-
-    function_name = JsFunctionNameToClassName(namespace_name, function.name)
-    c.Append("registry->RegisterFunction<%sFunction>();" % (
-        function_name))
-
-    if function_ifdefs is not None:
-      c.Append("#endif  // %s" % function_ifdefs, indent_level=0)
-    return c
-
-  def _GenerateFunctionRegistryRegisterAll(self):
-    c = code.Code()
-    c.Append('// static')
-    c.Sblock('void GeneratedFunctionRegistry::RegisterAll('
-                 'ExtensionFunctionRegistry* registry) {')
-    for namespace in self._model.namespaces.values():
-      namespace_ifdefs = self._GetPlatformIfdefs(namespace)
-      if namespace_ifdefs is not None:
-        c.Append("#if %s" % namespace_ifdefs, indent_level=0)
-
-      namespace_name = CapitalizeFirstLetter(namespace.name.replace(
-          "experimental.", ""))
-      for function in namespace.functions.values():
-        if function.nocompile:
-          continue
-        c.Concat(self._GenerateRegisterFunctions(namespace.name, function))
-
-      for type_ in namespace.types.values():
-        for function in type_.functions.values():
-          if function.nocompile:
-            continue
-          namespace_types_name = JsFunctionNameToClassName(
-                namespace.name, type_.name)
-          c.Concat(self._GenerateRegisterFunctions(namespace_types_name,
-                                                   function))
-
-      if namespace_ifdefs is not None:
-        c.Append("#endif  // %s" % namespace_ifdefs, indent_level=0)
-    c.Eblock("}")
-    return c
-
-
-class _APIHGenerator(object):
-  """Generates the header for API registration / declaration"""
-  def __init__(self, cpp_bundle):
-    self._bundle = cpp_bundle
-
-  def Generate(self, _):  # namespace not relevant, this is a bundle
-    c = code.Code()
-
-    c.Append('#include <string>')
-    c.Append()
-    c.Append('#include "base/basictypes.h"')
-    c.Append()
-    c.Append("class ExtensionFunctionRegistry;")
-    c.Append()
-    c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace))
-    c.Append()
-    c.Append('class GeneratedFunctionRegistry {')
-    c.Sblock(' public:')
-    c.Append('static void RegisterAll('
-                 'ExtensionFunctionRegistry* registry);')
-    c.Eblock('};')
-    c.Append()
-    c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))
-    return self._bundle._GenerateHeader('generated_api', c)
-
-
-class _APICCGenerator(object):
-  """Generates a code.Code object for the generated API .cc file"""
-
-  def __init__(self, cpp_bundle):
-    self._bundle = cpp_bundle
-
-  def Generate(self, _):  # namespace not relevant, this is a bundle
-    c = code.Code()
-    c.Append(cpp_util.CHROMIUM_LICENSE)
-    c.Append()
-    c.Append('#include "%s"' % (
-        os.path.join(self._bundle._impl_dir,
-                     'generated_api_registration.h')))
-    c.Append()
-    for namespace in self._bundle._model.namespaces.values():
-      namespace_name = namespace.unix_name.replace("experimental_", "")
-      implementation_header = namespace.compiler_options.get(
-          "implemented_in",
-          "%s/%s/%s_api.h" % (self._bundle._impl_dir,
-                              namespace_name,
-                              namespace_name))
-      if not os.path.exists(
-          os.path.join(self._bundle._root,
-                       os.path.normpath(implementation_header))):
-        if "implemented_in" in namespace.compiler_options:
-          raise ValueError('Header file for namespace "%s" specified in '
-                          'compiler_options not found: %s' %
-                          (namespace.unix_name, implementation_header))
-        continue
-      ifdefs = self._bundle._GetPlatformIfdefs(namespace)
-      if ifdefs is not None:
-        c.Append("#if %s" % ifdefs, indent_level=0)
-
-      c.Append('#include "%s"' % implementation_header)
-
-      if ifdefs is not None:
-        c.Append("#endif  // %s" % ifdefs, indent_level=0)
-    c.Append()
-    c.Append('#include '
-                 '"extensions/browser/extension_function_registry.h"')
-    c.Append()
-    c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace))
-    c.Append()
-    c.Concat(self._bundle._GenerateFunctionRegistryRegisterAll())
-    c.Append()
-    c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))
-    c.Append()
-    return c
-
-
-class _SchemasHGenerator(object):
-  """Generates a code.Code object for the generated schemas .h file"""
-  def __init__(self, cpp_bundle):
-    self._bundle = cpp_bundle
-
-  def Generate(self, _):  # namespace not relevant, this is a bundle
-    c = code.Code()
-    c.Append('#include <map>')
-    c.Append('#include <string>')
-    c.Append()
-    c.Append('#include "base/strings/string_piece.h"')
-    c.Append()
-    c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace))
-    c.Append()
-    c.Append('class GeneratedSchemas {')
-    c.Sblock(' public:')
-    c.Append('// Determines if schema named |name| is generated.')
-    c.Append('static bool IsGenerated(std::string name);')
-    c.Append()
-    c.Append('// Gets the API schema named |name|.')
-    c.Append('static base::StringPiece Get(const std::string& name);')
-    c.Eblock('};')
-    c.Append()
-    c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))
-    return self._bundle._GenerateHeader('generated_schemas', c)
-
-
-def _FormatNameAsConstant(name):
-  """Formats a name to be a C++ constant of the form kConstantName"""
-  name = '%s%s' % (name[0].upper(), name[1:])
-  return 'k%s' % re.sub('_[a-z]',
-                        lambda m: m.group(0)[1].upper(),
-                        name.replace('.', '_'))
-
-
-class _SchemasCCGenerator(object):
-  """Generates a code.Code object for the generated schemas .cc file"""
-
-  def __init__(self, cpp_bundle):
-    self._bundle = cpp_bundle
-
-  def Generate(self, _):  # namespace not relevant, this is a bundle
-    c = code.Code()
-    c.Append(cpp_util.CHROMIUM_LICENSE)
-    c.Append()
-    c.Append('#include "%s"' % (os.path.join(self._bundle._source_file_dir,
-                                             'generated_schemas.h')))
-    c.Append()
-    c.Append('#include "base/lazy_instance.h"')
-    c.Append()
-    c.Append('namespace {')
-    for api in self._bundle._api_defs:
-      namespace = self._bundle._model.namespaces[api.get('namespace')]
-      # JSON parsing code expects lists of schemas, so dump a singleton list.
-      json_content = json.dumps([_RemoveDescriptions(api)],
-                                separators=(',', ':'))
-      # Escape all double-quotes and backslashes. For this to output a valid
-      # JSON C string, we need to escape \ and ". Note that some schemas are
-      # too large to compile on windows. Split the JSON up into several
-      # strings, since apparently that helps.
-      max_length = 8192
-      segments = [json_content[i:i + max_length].replace('\\', '\\\\')
-                                                .replace('"', '\\"')
-                  for i in xrange(0, len(json_content), max_length)]
-      c.Append('const char %s[] = "%s";' %
-          (_FormatNameAsConstant(namespace.name), '" "'.join(segments)))
-    c.Append('}')
-    c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace))
-    c.Append()
-    c.Sblock('struct Static {')
-    c.Sblock('Static() {')
-    for api in self._bundle._api_defs:
-      namespace = self._bundle._model.namespaces[api.get('namespace')]
-      c.Append('schemas["%s"] = %s;' % (namespace.name,
-                                        _FormatNameAsConstant(namespace.name)))
-    c.Eblock('}')
-    c.Append()
-    c.Append('std::map<std::string, const char*> schemas;')
-    c.Eblock('};')
-    c.Append()
-    c.Append('base::LazyInstance<Static> g_lazy_instance;')
-    c.Append()
-    c.Append('// static')
-    c.Sblock('base::StringPiece GeneratedSchemas::Get('
-                  'const std::string& name) {')
-    c.Append('return IsGenerated(name) ? '
-             'g_lazy_instance.Get().schemas[name] : "";')
-    c.Eblock('}')
-    c.Append()
-    c.Append('// static')
-    c.Sblock('bool GeneratedSchemas::IsGenerated(std::string name) {')
-    c.Append('return g_lazy_instance.Get().schemas.count(name) > 0;')
-    c.Eblock('}')
-    c.Append()
-    c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))
-    c.Append()
-    return c
diff --git a/tools/json_schema_compiler/cpp_generator.py b/tools/json_schema_compiler/cpp_generator.py
deleted file mode 100644
index 5521ea9..0000000
--- a/tools/json_schema_compiler/cpp_generator.py
+++ /dev/null
@@ -1,11 +0,0 @@
-# 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.
-
-from cc_generator import CCGenerator
-from h_generator import HGenerator
-
-class CppGenerator(object):
-  def __init__(self, type_generator):
-    self.h_generator = HGenerator(type_generator)
-    self.cc_generator = CCGenerator(type_generator)
diff --git a/tools/json_schema_compiler/cpp_namespace_environment.py b/tools/json_schema_compiler/cpp_namespace_environment.py
deleted file mode 100644
index 20e77bb..0000000
--- a/tools/json_schema_compiler/cpp_namespace_environment.py
+++ /dev/null
@@ -1,7 +0,0 @@
-# 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.
-
-class CppNamespaceEnvironment(object):
-  def __init__(self, namespace_pattern):
-    self.namespace_pattern = namespace_pattern
diff --git a/tools/json_schema_compiler/cpp_type_generator.py b/tools/json_schema_compiler/cpp_type_generator.py
deleted file mode 100644
index 6bec67e..0000000
--- a/tools/json_schema_compiler/cpp_type_generator.py
+++ /dev/null
@@ -1,273 +0,0 @@
-# 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.
-
-from code import Code
-from model import PropertyType
-import cpp_util
-from json_parse import OrderedDict
-import schema_util
-
-class _TypeDependency(object):
-  """Contains information about a dependency a namespace has on a type: the
-  type's model, and whether that dependency is "hard" meaning that it cannot be
-  forward declared.
-  """
-  def __init__(self, type_, hard=False):
-    self.type_ = type_
-    self.hard = hard
-
-  def GetSortKey(self):
-    return '%s.%s' % (self.type_.namespace.name, self.type_.name)
-
-
-class CppTypeGenerator(object):
-  """Manages the types of properties and provides utilities for getting the
-  C++ type out of a model.Property
-  """
-  def __init__(self, model, schema_loader, default_namespace=None):
-    """Creates a cpp_type_generator. The given root_namespace should be of the
-    format extensions::api::sub. The generator will generate code suitable for
-    use in the given model's namespace.
-    """
-    self._default_namespace = default_namespace
-    if self._default_namespace is None:
-      self._default_namespace = model.namespaces.values()[0]
-    self._schema_loader = schema_loader
-
-  def GetEnumNoneValue(self, type_):
-    """Gets the enum value in the given model.Property indicating no value has
-    been set.
-    """
-    return '%s_NONE' % self.FollowRef(type_).unix_name.upper()
-
-  def GetEnumLastValue(self, type_):
-    """Gets the enum value in the given model.Property indicating the last value
-    for the type.
-    """
-    return '%s_LAST' % self.FollowRef(type_).unix_name.upper()
-
-  def GetEnumValue(self, type_, enum_value):
-    """Gets the enum value of the given model.Property of the given type.
-
-    e.g VAR_STRING
-    """
-    value = cpp_util.Classname(enum_value.name.upper())
-    prefix = (type_.cpp_enum_prefix_override or
-              self.FollowRef(type_).unix_name)
-    value = '%s_%s' % (prefix.upper(), value)
-    # To avoid collisions with built-in OS_* preprocessor definitions, we add a
-    # trailing slash to enum names that start with OS_.
-    if value.startswith("OS_"):
-      value += "_"
-    return value
-
-  def GetCppType(self, type_, is_ptr=False, is_in_container=False):
-    """Translates a model.Property or model.Type into its C++ type.
-
-    If REF types from different namespaces are referenced, will resolve
-    using self._schema_loader.
-
-    Use |is_ptr| if the type is optional. This will wrap the type in a
-    scoped_ptr if possible (it is not possible to wrap an enum).
-
-    Use |is_in_container| if the type is appearing in a collection, e.g. a
-    std::vector or std::map. This will wrap it in the correct type with spacing.
-    """
-    cpp_type = None
-    if type_.property_type == PropertyType.REF:
-      ref_type = self._FindType(type_.ref_type)
-      if ref_type is None:
-        raise KeyError('Cannot find referenced type: %s' % type_.ref_type)
-      cpp_type = self.GetCppType(ref_type)
-    elif type_.property_type == PropertyType.BOOLEAN:
-      cpp_type = 'bool'
-    elif type_.property_type == PropertyType.INTEGER:
-      cpp_type = 'int'
-    elif type_.property_type == PropertyType.INT64:
-      cpp_type = 'int64'
-    elif type_.property_type == PropertyType.DOUBLE:
-      cpp_type = 'double'
-    elif type_.property_type == PropertyType.STRING:
-      cpp_type = 'std::string'
-    elif type_.property_type in (PropertyType.ENUM,
-                                 PropertyType.OBJECT,
-                                 PropertyType.CHOICES):
-      if self._default_namespace is type_.namespace:
-        cpp_type = cpp_util.Classname(type_.name)
-      else:
-        cpp_namespace = cpp_util.GetCppNamespace(
-            type_.namespace.environment.namespace_pattern,
-            type_.namespace.unix_name)
-        cpp_type = '%s::%s' % (cpp_namespace,
-                               cpp_util.Classname(type_.name))
-    elif type_.property_type == PropertyType.ANY:
-      cpp_type = 'base::Value'
-    elif type_.property_type == PropertyType.FUNCTION:
-      # Functions come into the json schema compiler as empty objects. We can
-      # record these as empty DictionaryValues so that we know if the function
-      # was passed in or not.
-      cpp_type = 'base::DictionaryValue'
-    elif type_.property_type == PropertyType.ARRAY:
-      item_cpp_type = self.GetCppType(type_.item_type, is_in_container=True)
-      cpp_type = 'std::vector<%s>' % cpp_util.PadForGenerics(item_cpp_type)
-    elif type_.property_type == PropertyType.BINARY:
-      cpp_type = 'std::string'
-    else:
-      raise NotImplementedError('Cannot get type of %s' % type_.property_type)
-
-    # HACK: optional ENUM is represented elsewhere with a _NONE value, so it
-    # never needs to be wrapped in pointer shenanigans.
-    # TODO(kalman): change this - but it's an exceedingly far-reaching change.
-    if not self.FollowRef(type_).property_type == PropertyType.ENUM:
-      if is_in_container and (is_ptr or not self.IsCopyable(type_)):
-        cpp_type = 'linked_ptr<%s>' % cpp_util.PadForGenerics(cpp_type)
-      elif is_ptr:
-        cpp_type = 'scoped_ptr<%s>' % cpp_util.PadForGenerics(cpp_type)
-
-    return cpp_type
-
-  def IsCopyable(self, type_):
-    return not (self.FollowRef(type_).property_type in (PropertyType.ANY,
-                                                        PropertyType.ARRAY,
-                                                        PropertyType.OBJECT,
-                                                        PropertyType.CHOICES))
-
-  def GenerateForwardDeclarations(self):
-    """Returns the forward declarations for self._default_namespace.
-    """
-    c = Code()
-    for namespace, deps in self._NamespaceTypeDependencies().iteritems():
-      filtered_deps = [
-        dep for dep in deps
-        # Add more ways to forward declare things as necessary.
-        if (not dep.hard and
-            dep.type_.property_type in (PropertyType.CHOICES,
-                                        PropertyType.OBJECT))]
-      if not filtered_deps:
-        continue
-
-      cpp_namespace = cpp_util.GetCppNamespace(
-          namespace.environment.namespace_pattern,
-          namespace.unix_name)
-      c.Concat(cpp_util.OpenNamespace(cpp_namespace))
-      for dep in filtered_deps:
-        c.Append('struct %s;' % dep.type_.name)
-      c.Concat(cpp_util.CloseNamespace(cpp_namespace))
-    return c
-
-  def GenerateIncludes(self, include_soft=False):
-    """Returns the #include lines for self._default_namespace.
-    """
-    c = Code()
-    for namespace, dependencies in self._NamespaceTypeDependencies().items():
-      for dependency in dependencies:
-        if dependency.hard or include_soft:
-          c.Append('#include "%s/%s.h"' % (namespace.source_file_dir,
-                                           namespace.unix_name))
-    return c
-
-  def _FindType(self, full_name):
-    """Finds the model.Type with name |qualified_name|. If it's not from
-    |self._default_namespace| then it needs to be qualified.
-    """
-    namespace = self._schema_loader.ResolveType(full_name,
-                                                self._default_namespace)
-    if namespace is None:
-      raise KeyError('Cannot resolve type %s. Maybe it needs a prefix '
-                     'if it comes from another namespace?' % full_name)
-    return namespace.types[schema_util.StripNamespace(full_name)]
-
-  def FollowRef(self, type_):
-    """Follows $ref link of types to resolve the concrete type a ref refers to.
-
-    If the property passed in is not of type PropertyType.REF, it will be
-    returned unchanged.
-    """
-    if type_.property_type != PropertyType.REF:
-      return type_
-    return self.FollowRef(self._FindType(type_.ref_type))
-
-  def _NamespaceTypeDependencies(self):
-    """Returns a dict ordered by namespace name containing a mapping of
-    model.Namespace to every _TypeDependency for |self._default_namespace|,
-    sorted by the type's name.
-    """
-    dependencies = set()
-    for function in self._default_namespace.functions.values():
-      for param in function.params:
-        dependencies |= self._TypeDependencies(param.type_,
-                                               hard=not param.optional)
-      if function.callback:
-        for param in function.callback.params:
-          dependencies |= self._TypeDependencies(param.type_,
-                                                 hard=not param.optional)
-    for type_ in self._default_namespace.types.values():
-      for prop in type_.properties.values():
-        dependencies |= self._TypeDependencies(prop.type_,
-                                               hard=not prop.optional)
-    for event in self._default_namespace.events.values():
-      for param in event.params:
-        dependencies |= self._TypeDependencies(param.type_,
-                                               hard=not param.optional)
-
-    # Make sure that the dependencies are returned in alphabetical order.
-    dependency_namespaces = OrderedDict()
-    for dependency in sorted(dependencies, key=_TypeDependency.GetSortKey):
-      namespace = dependency.type_.namespace
-      if namespace is self._default_namespace:
-        continue
-      if namespace not in dependency_namespaces:
-        dependency_namespaces[namespace] = []
-      dependency_namespaces[namespace].append(dependency)
-
-    return dependency_namespaces
-
-  def _TypeDependencies(self, type_, hard=False):
-    """Gets all the type dependencies of a property.
-    """
-    deps = set()
-    if type_.property_type == PropertyType.REF:
-      deps.add(_TypeDependency(self._FindType(type_.ref_type), hard=hard))
-    elif type_.property_type == PropertyType.ARRAY:
-      # Non-copyable types are not hard because they are wrapped in linked_ptrs
-      # when generated. Otherwise they're typedefs, so they're hard (though we
-      # could generate those typedefs in every dependent namespace, but that
-      # seems weird).
-      deps = self._TypeDependencies(type_.item_type,
-                                    hard=self.IsCopyable(type_.item_type))
-    elif type_.property_type == PropertyType.CHOICES:
-      for type_ in type_.choices:
-        deps |= self._TypeDependencies(type_, hard=self.IsCopyable(type_))
-    elif type_.property_type == PropertyType.OBJECT:
-      for p in type_.properties.values():
-        deps |= self._TypeDependencies(p.type_, hard=not p.optional)
-    return deps
-
-  def GeneratePropertyValues(self, property, line, nodoc=False):
-    """Generates the Code to display all value-containing properties.
-    """
-    c = Code()
-    if not nodoc:
-      c.Comment(property.description)
-
-    if property.value is not None:
-      c.Append(line % {
-          "type": self.GetCppType(property.type_),
-          "name": property.name,
-          "value": property.value
-        })
-    else:
-      has_child_code = False
-      c.Sblock('namespace %s {' % property.name)
-      for child_property in property.type_.properties.values():
-        child_code = self.GeneratePropertyValues(child_property,
-                                                 line,
-                                                 nodoc=nodoc)
-        if child_code:
-          has_child_code = True
-          c.Concat(child_code)
-      c.Eblock('}  // namespace %s' % property.name)
-      if not has_child_code:
-        c = None
-    return c
diff --git a/tools/json_schema_compiler/cpp_type_generator_test.py b/tools/json_schema_compiler/cpp_type_generator_test.py
deleted file mode 100755
index 51fcfe9..0000000
--- a/tools/json_schema_compiler/cpp_type_generator_test.py
+++ /dev/null
@@ -1,193 +0,0 @@
-#!/usr/bin/env python
-# 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.
-
-from cpp_namespace_environment import CppNamespaceEnvironment
-from cpp_type_generator import CppTypeGenerator
-from json_schema import CachedLoad
-import model
-import unittest
-
-from collections import defaultdict
-
-class _FakeSchemaLoader(object):
-  def __init__(self, model):
-    self._model = model
-
-  def ResolveType(self, type_name, default):
-    parts = type_name.rsplit('.', 1)
-    if len(parts) == 1:
-      return default if type_name in default.types else None
-    return self._model.namespaces[parts[0]]
-
-class CppTypeGeneratorTest(unittest.TestCase):
-  def setUp(self):
-    self.models = defaultdict(model.Model)
-
-    self.forbidden_json = CachedLoad('test/forbidden.json')
-    self.forbidden = self.models['forbidden'].AddNamespace(
-        self.forbidden_json[0], 'path/to/forbidden.json')
-    self.permissions_json = CachedLoad('test/permissions.json')
-    self.permissions = self.models['permissions'].AddNamespace(
-        self.permissions_json[0], 'path/to/permissions.json')
-    self.windows_json = CachedLoad('test/windows.json')
-    self.windows = self.models['windows'].AddNamespace(self.windows_json[0],
-                                                       'path/to/window.json')
-    self.tabs_json = CachedLoad('test/tabs.json')
-    self.tabs = self.models['tabs'].AddNamespace(self.tabs_json[0],
-                                                 'path/to/tabs.json')
-    self.browser_action_json = CachedLoad('test/browser_action.json')
-    self.browser_action = self.models['browser_action'].AddNamespace(
-        self.browser_action_json[0], 'path/to/browser_action.json')
-    self.font_settings_json = CachedLoad('test/font_settings.json')
-    self.font_settings = self.models['font_settings'].AddNamespace(
-        self.font_settings_json[0], 'path/to/font_settings.json')
-    self.dependency_tester_json = CachedLoad('test/dependency_tester.json')
-    self.dependency_tester = self.models['dependency_tester'].AddNamespace(
-        self.dependency_tester_json[0], 'path/to/dependency_tester.json')
-    self.content_settings_json = CachedLoad('test/content_settings.json')
-    self.content_settings = self.models['content_settings'].AddNamespace(
-        self.content_settings_json[0], 'path/to/content_settings.json')
-
-  def testGenerateIncludesAndForwardDeclarations(self):
-    m = model.Model()
-    m.AddNamespace(self.windows_json[0],
-                   'path/to/windows.json',
-                   environment=CppNamespaceEnvironment('%(namespace)s'))
-    m.AddNamespace(self.tabs_json[0],
-                   'path/to/tabs.json',
-                   environment=CppNamespaceEnvironment('%(namespace)s'))
-    manager = CppTypeGenerator(m, _FakeSchemaLoader(m))
-
-    self.assertEquals('', manager.GenerateIncludes().Render())
-    self.assertEquals('#include "path/to/tabs.h"',
-                      manager.GenerateIncludes(include_soft=True).Render())
-    self.assertEquals(
-        'namespace tabs {\n'
-        'struct Tab;\n'
-        '}  // namespace tabs',
-        manager.GenerateForwardDeclarations().Render())
-
-    m = model.Model()
-    m.AddNamespace(self.windows_json[0],
-                   'path/to/windows.json',
-                   environment=CppNamespaceEnvironment(
-                       'foo::bar::%(namespace)s'))
-    m.AddNamespace(self.tabs_json[0],
-                   'path/to/tabs.json',
-                   environment=CppNamespaceEnvironment(
-                       'foo::bar::%(namespace)s'))
-    manager = CppTypeGenerator(m, _FakeSchemaLoader(m))
-    self.assertEquals(
-        'namespace foo {\n'
-        'namespace bar {\n'
-        'namespace tabs {\n'
-        'struct Tab;\n'
-        '}  // namespace tabs\n'
-        '}  // namespace bar\n'
-        '}  // namespace foo',
-        manager.GenerateForwardDeclarations().Render())
-    manager = CppTypeGenerator(self.models.get('permissions'),
-                               _FakeSchemaLoader(m))
-    self.assertEquals('', manager.GenerateIncludes().Render())
-    self.assertEquals('', manager.GenerateIncludes().Render())
-    self.assertEquals('', manager.GenerateForwardDeclarations().Render())
-    manager = CppTypeGenerator(self.models.get('content_settings'),
-                               _FakeSchemaLoader(m))
-    self.assertEquals('', manager.GenerateIncludes().Render())
-
-  def testGenerateIncludesAndForwardDeclarationsDependencies(self):
-    m = model.Model()
-    # Insert 'font_settings' before 'browser_action' in order to test that
-    # CppTypeGenerator sorts them properly.
-    m.AddNamespace(self.font_settings_json[0], 'path/to/font_settings.json')
-    m.AddNamespace(self.browser_action_json[0], 'path/to/browser_action.json')
-    dependency_tester = m.AddNamespace(self.dependency_tester_json[0],
-                                       'path/to/dependency_tester.json')
-    manager = CppTypeGenerator(m,
-                               _FakeSchemaLoader(m),
-                               default_namespace=dependency_tester)
-    self.assertEquals('#include "path/to/browser_action.h"\n'
-                      '#include "path/to/font_settings.h"',
-                      manager.GenerateIncludes().Render())
-    self.assertEquals('', manager.GenerateForwardDeclarations().Render())
-
-  def testGetCppTypeSimple(self):
-    manager = CppTypeGenerator(self.models.get('tabs'), _FakeSchemaLoader(None))
-    self.assertEquals(
-        'int',
-        manager.GetCppType(self.tabs.types['Tab'].properties['id'].type_))
-    self.assertEquals(
-        'std::string',
-        manager.GetCppType(self.tabs.types['Tab'].properties['status'].type_))
-    self.assertEquals(
-        'bool',
-        manager.GetCppType(self.tabs.types['Tab'].properties['selected'].type_))
-
-  def testStringAsType(self):
-    manager = CppTypeGenerator(self.models.get('font_settings'),
-                               _FakeSchemaLoader(None))
-    self.assertEquals(
-        'std::string',
-        manager.GetCppType(self.font_settings.types['FakeStringType']))
-
-  def testArrayAsType(self):
-    manager = CppTypeGenerator(self.models.get('browser_action'),
-                               _FakeSchemaLoader(None))
-    self.assertEquals(
-        'std::vector<int>',
-        manager.GetCppType(self.browser_action.types['ColorArray']))
-
-  def testGetCppTypeArray(self):
-    manager = CppTypeGenerator(self.models.get('windows'),
-                                _FakeSchemaLoader(None))
-    self.assertEquals(
-        'std::vector<linked_ptr<Window> >',
-        manager.GetCppType(
-            self.windows.functions['getAll'].callback.params[0].type_))
-    manager = CppTypeGenerator(self.models.get('permissions'),
-                               _FakeSchemaLoader(None))
-    self.assertEquals(
-        'std::vector<std::string>',
-        manager.GetCppType(
-            self.permissions.types['Permissions'].properties['origins'].type_))
-
-  def testGetCppTypeLocalRef(self):
-    manager = CppTypeGenerator(self.models.get('tabs'), _FakeSchemaLoader(None))
-    self.assertEquals(
-        'Tab',
-        manager.GetCppType(self.tabs.functions['get'].callback.params[0].type_))
-
-  def testGetCppTypeIncludedRef(self):
-    m = model.Model()
-    m.AddNamespace(self.windows_json[0],
-                   'path/to/windows.json',
-                   environment=CppNamespaceEnvironment('%(namespace)s'))
-    m.AddNamespace(self.tabs_json[0],
-                   'path/to/tabs.json',
-                   environment=CppNamespaceEnvironment('%(namespace)s'))
-    manager = CppTypeGenerator(m, _FakeSchemaLoader(m))
-    self.assertEquals(
-        'std::vector<linked_ptr<tabs::Tab> >',
-        manager.GetCppType(
-            self.windows.types['Window'].properties['tabs'].type_))
-
-  def testGetCppTypeWithPadForGeneric(self):
-    manager = CppTypeGenerator(self.models.get('permissions'),
-                               _FakeSchemaLoader(None))
-    self.assertEquals('std::vector<std::string>',
-        manager.GetCppType(
-            self.permissions.types['Permissions'].properties['origins'].type_,
-            is_in_container=False))
-    self.assertEquals('linked_ptr<std::vector<std::string> >',
-        manager.GetCppType(
-            self.permissions.types['Permissions'].properties['origins'].type_,
-            is_in_container=True))
-    self.assertEquals('bool',
-        manager.GetCppType(
-            self.permissions.functions['contains'].callback.params[0].type_,
-        is_in_container=True))
-
-if __name__ == '__main__':
-  unittest.main()
diff --git a/tools/json_schema_compiler/cpp_util.py b/tools/json_schema_compiler/cpp_util.py
deleted file mode 100644
index 187d99f..0000000
--- a/tools/json_schema_compiler/cpp_util.py
+++ /dev/null
@@ -1,158 +0,0 @@
-# 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.
-
-"""Utilies and constants specific to Chromium C++ code.
-"""
-
-from code import Code
-from datetime import datetime
-from model import PropertyType
-import os
-import re
-
-CHROMIUM_LICENSE = (
-"""// Copyright (c) %d 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.""" % datetime.now().year
-)
-GENERATED_FILE_MESSAGE = """// GENERATED FROM THE API DEFINITION IN
-//   %s
-// DO NOT EDIT.
-"""
-GENERATED_BUNDLE_FILE_MESSAGE = """// GENERATED FROM THE API DEFINITIONS IN
-//   %s
-// DO NOT EDIT.
-"""
-GENERATED_FEATURE_MESSAGE = """// GENERATED FROM THE FEATURE DEFINITIONS IN
-//   %s
-// DO NOT EDIT.
-"""
-
-def Classname(s):
-  """Translates a namespace name or function name into something more
-  suited to C++.
-
-  eg experimental.downloads -> Experimental_Downloads
-  updateAll -> UpdateAll.
-  """
-  return '_'.join([x[0].upper() + x[1:] for x in re.split('\W', s)])
-
-
-def GetAsFundamentalValue(type_, src, dst):
-  """Returns the C++ code for retrieving a fundamental type from a
-  Value into a variable.
-
-  src: Value*
-  dst: Property*
-  """
-  return {
-      PropertyType.BOOLEAN: '%s->GetAsBoolean(%s)',
-      PropertyType.DOUBLE: '%s->GetAsDouble(%s)',
-      PropertyType.INTEGER: '%s->GetAsInteger(%s)',
-      PropertyType.STRING: '%s->GetAsString(%s)',
-  }[type_.property_type] % (src, dst)
-
-
-def GetValueType(type_):
-  """Returns the Value::Type corresponding to the model.Type.
-  """
-  return {
-      PropertyType.ARRAY: 'base::Value::TYPE_LIST',
-      PropertyType.BINARY: 'base::Value::TYPE_BINARY',
-      PropertyType.BOOLEAN: 'base::Value::TYPE_BOOLEAN',
-      # PropertyType.CHOICES can be any combination of types.
-      PropertyType.DOUBLE: 'base::Value::TYPE_DOUBLE',
-      PropertyType.ENUM: 'base::Value::TYPE_STRING',
-      PropertyType.FUNCTION: 'base::Value::TYPE_DICTIONARY',
-      PropertyType.INTEGER: 'base::Value::TYPE_INTEGER',
-      PropertyType.OBJECT: 'base::Value::TYPE_DICTIONARY',
-      PropertyType.STRING: 'base::Value::TYPE_STRING',
-  }[type_.property_type]
-
-
-def GetParameterDeclaration(param, type_):
-  """Gets a parameter declaration of a given model.Property and its C++
-  type.
-  """
-  if param.type_.property_type in (PropertyType.ANY,
-                                   PropertyType.ARRAY,
-                                   PropertyType.CHOICES,
-                                   PropertyType.OBJECT,
-                                   PropertyType.REF,
-                                   PropertyType.STRING):
-    arg = 'const %(type)s& %(name)s'
-  else:
-    arg = '%(type)s %(name)s'
-  return arg % {
-    'type': type_,
-    'name': param.unix_name,
-  }
-
-
-def GenerateIfndefName(file_path):
-  """Formats |file_path| as a #define name. Presumably |file_path| is a header
-  file, or there's little point in generating a #define for it.
-
-  e.g chrome/extensions/gen/file.h becomes CHROME_EXTENSIONS_GEN_FILE_H__.
-  """
-  return (('%s__' % file_path).upper()
-      .replace('\\', '_')
-      .replace('/', '_')
-      .replace('.', '_'))
-
-
-def PadForGenerics(var):
-  """Appends a space to |var| if it ends with a >, so that it can be compiled
-  within generic types.
-  """
-  return ('%s ' % var) if var.endswith('>') else var
-
-
-
-def OpenNamespace(cpp_namespace):
-  """Get opening root namespace declarations.
-  """
-  c = Code()
-  for component in cpp_namespace.split('::'):
-    c.Append('namespace %s {' % component)
-  return c
-
-
-def CloseNamespace(cpp_namespace):
-  """Get closing root namespace declarations.
-  """
-  c = Code()
-  for component in reversed(cpp_namespace.split('::')):
-    c.Append('}  // namespace %s' % component)
-  return c
-
-
-def ConstantName(feature_name):
-  """Returns a kName for a feature's name.
-  """
-  return ('k' + ''.join(word[0].upper() + word[1:]
-      for word in feature_name.replace('.', ' ').split()))
-
-
-def CamelCase(unix_name):
-  return ''.join(word.capitalize() for word in unix_name.split('_'))
-
-
-def ClassName(filepath):
-  return CamelCase(os.path.split(filepath)[1])
-
-
-def GetCppNamespace(pattern, namespace):
-  '''Returns the C++ namespace given |pattern| which includes a %(namespace)s
-  substitution, and the |namespace| to substitute. It is expected that |pattern|
-  has been passed as a flag to compiler.py from GYP/GN.
-  '''
-  # For some reason Windows builds escape the % characters, so unescape them.
-  # This means that %% can never appear legitimately within a pattern, but
-  # that's ok. It should never happen.
-  cpp_namespace = pattern.replace('%%', '%') % { 'namespace': namespace }
-  assert '%' not in cpp_namespace, \
-         ('Did not manage to fully substitute namespace "%s" into pattern "%s"'
-           % (namespace, pattern))
-  return cpp_namespace
diff --git a/tools/json_schema_compiler/cpp_util_test.py b/tools/json_schema_compiler/cpp_util_test.py
deleted file mode 100755
index eef4c55..0000000
--- a/tools/json_schema_compiler/cpp_util_test.py
+++ /dev/null
@@ -1,63 +0,0 @@
-#!/usr/bin/env python
-# 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.
-
-import unittest
-
-from cpp_util import (
-    Classname, CloseNamespace, GenerateIfndefName, OpenNamespace)
-
-class CppUtilTest(unittest.TestCase):
-  def testClassname(self):
-    self.assertEquals('Permissions', Classname('permissions'))
-    self.assertEquals('UpdateAllTheThings',
-        Classname('updateAllTheThings'))
-    self.assertEquals('Aa_Bb_Cc', Classname('aa.bb.cc'))
-
-  def testNamespaceDeclaration(self):
-    self.assertEquals('namespace foo {',
-                      OpenNamespace('foo').Render())
-    self.assertEquals('}  // namespace foo',
-                      CloseNamespace('foo').Render())
-
-    self.assertEquals(
-        'namespace extensions {\n'
-        'namespace foo {',
-        OpenNamespace('extensions::foo').Render())
-    self.assertEquals(
-        '}  // namespace foo\n'
-        '}  // namespace extensions',
-        CloseNamespace('extensions::foo').Render())
-
-    self.assertEquals(
-        'namespace extensions {\n'
-        'namespace gen {\n'
-        'namespace api {',
-        OpenNamespace('extensions::gen::api').Render())
-    self.assertEquals(
-        '}  // namespace api\n'
-        '}  // namespace gen\n'
-        '}  // namespace extensions',
-        CloseNamespace('extensions::gen::api').Render())
-
-    self.assertEquals(
-        'namespace extensions {\n'
-        'namespace gen {\n'
-        'namespace api {\n'
-        'namespace foo {',
-        OpenNamespace('extensions::gen::api::foo').Render())
-    self.assertEquals(
-        '}  // namespace foo\n'
-        '}  // namespace api\n'
-        '}  // namespace gen\n'
-        '}  // namespace extensions',
-        CloseNamespace('extensions::gen::api::foo').Render())
-
-  def testGenerateIfndefName(self):
-    self.assertEquals('FOO_BAR_BAZ_H__', GenerateIfndefName('foo\\bar\\baz.h'))
-    self.assertEquals('FOO_BAR_BAZ_H__', GenerateIfndefName('foo/bar/baz.h'))
-
-
-if __name__ == '__main__':
-  unittest.main()
diff --git a/tools/json_schema_compiler/dart_generator.py b/tools/json_schema_compiler/dart_generator.py
deleted file mode 100644
index a9ba0d6..0000000
--- a/tools/json_schema_compiler/dart_generator.py
+++ /dev/null
@@ -1,763 +0,0 @@
-# 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.
-"""
-Generator language component for compiler.py that adds Dart language support.
-"""
-
-from code import Code
-from model import Function, PropertyType
-from schema_util import StripNamespace
-
-import os
-from datetime import datetime
-
-LICENSE = (
-"""// Copyright (c) %s, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.""" %
-    datetime.now().year)
-
-class DartGenerator(object):
-  def __init__(self, dart_overrides_dir=None):
-    self._dart_overrides_dir = dart_overrides_dir
-
-  def Generate(self, namespace):
-    return _Generator(namespace, self._dart_overrides_dir).Generate()
-
-
-class _Generator(object):
-  """A .dart generator for a namespace.
-  """
-
-  def __init__(self, namespace, dart_overrides_dir=None):
-    self._namespace = namespace
-    # TODO(sashab): Once inline type definitions start being added to
-    # self._types, make a _FindType(self, type_) function that looks at
-    # self._namespace.types.
-    self._types = namespace.types
-
-    # Build a dictionary of Type Name --> Custom Dart code.
-    self._type_overrides = {}
-    if dart_overrides_dir is not None:
-      for filename in os.listdir(dart_overrides_dir):
-        if filename.startswith(namespace.unix_name):
-          with open(os.path.join(dart_overrides_dir, filename)) as f:
-            # Split off the namespace and file extension, leaving just the type.
-            type_path = '.'.join(filename.split('.')[1:-1])
-            self._type_overrides[type_path] = f.read()
-
-    # TODO(sashab): Add all inline type definitions to the global Types
-    # dictionary here, so they have proper names, and are implemented along with
-    # all other types. Also update the parameters/members with these types
-    # to reference these new types instead.
-
-  def Generate(self):
-    """Generates a Code object with the .dart for the entire namespace.
-    """
-    c = Code()
-    (c.Append(LICENSE)
-      .Append()
-      .Append('// Generated from namespace: %s' % self._namespace.name)
-      .Append()
-      .Append('part of chrome;'))
-
-    if self._types:
-      (c.Append()
-        .Append('/**')
-        .Append(' * Types')
-        .Append(' */')
-        .Append()
-      )
-    for type_ in self._types.values():
-      # Check for custom dart for this whole type.
-      override = self._GetOverride([type_.name], document_with=type_)
-      c.Cblock(override if override is not None else self._GenerateType(type_))
-
-    if self._namespace.events:
-      (c.Append('/**')
-        .Append(' * Events')
-        .Append(' */')
-        .Append()
-      )
-    for event_name in self._namespace.events:
-      c.Cblock(self._GenerateEvent(self._namespace.events[event_name]))
-
-    (c.Append('/**')
-      .Append(' * Functions')
-      .Append(' */')
-      .Append()
-    )
-    c.Cblock(self._GenerateMainClass())
-
-    return c
-
-  def _GenerateType(self, type_):
-    """Given a Type object, returns the Code with the .dart for this
-    type's definition.
-
-    Assumes this type is a Parameter Type (creatable by user), and creates an
-    object that extends ChromeObject. All parameters are specifiable as named
-    arguments in the constructor, and all methods are wrapped with getters and
-    setters that hide the JS() implementation.
-    """
-    c = Code()
-
-    # Since enums are just treated as strings for now, don't generate their
-    # type.
-    # TODO(sashab): Find a nice way to wrap enum objects.
-    if type_.property_type is PropertyType.ENUM:
-      return c
-
-    (c.Concat(self._GenerateDocumentation(type_))
-      .Sblock('class %(type_name)s extends ChromeObject {')
-    )
-
-    # Check whether this type has function members. If it does, don't allow
-    # public construction.
-    add_public_constructor = all(not self._IsFunction(p.type_)
-                                 for p in type_.properties.values())
-    constructor_fields = [self._GeneratePropertySignature(p)
-                          for p in type_.properties.values()]
-
-    if add_public_constructor:
-      (c.Append('/*')
-        .Append(' * Public constructor')
-        .Append(' */')
-        .Sblock('%(type_name)s({%(constructor_fields)s}) {')
-      )
-
-      for prop_name in type_.properties:
-        (c.Sblock('if (%s != null)' % prop_name)
-          .Append('this.%s = %s;' % (prop_name, prop_name))
-          .Eblock()
-        )
-      (c.Eblock('}')
-        .Append()
-      )
-
-    (c.Append('/*')
-      .Append(' * Private constructor')
-      .Append(' */')
-      .Append('%(type_name)s._proxy(_jsObject) : super._proxy(_jsObject);')
-    )
-
-    # Add an accessor (getter & setter) for each property.
-    properties = [p for p in type_.properties.values()
-                  if not self._IsFunction(p.type_)]
-    if properties:
-      (c.Append()
-        .Append('/*')
-        .Append(' * Public accessors')
-        .Append(' */')
-      )
-    for prop in properties:
-      override = self._GetOverride([type_.name, prop.name], document_with=prop)
-      c.Concat(override if override is not None
-               else self._GenerateGetterAndSetter(type_, prop))
-
-    # Now add all the methods.
-    methods = [t for t in type_.properties.values()
-               if self._IsFunction(t.type_)]
-    if methods:
-      (c.Append()
-        .Append('/*')
-        .Append(' * Methods')
-        .Append(' */')
-      )
-    for prop in methods:
-      # Check if there's an override for this method.
-      override = self._GetOverride([type_.name, prop.name], document_with=prop)
-      c.Cblock(override if override is not None
-               else self._GenerateFunction(prop.type_.function))
-
-    (c.Eblock('}')
-      .Substitute({
-        'type_name': self._AddPrefix(type_.simple_name),
-        'constructor_fields': ', '.join(constructor_fields)
-      })
-    )
-
-    return c
-
-  def _GenerateGetterAndSetter(self, type_, prop):
-    """Given a Type and Property, returns the Code object for the getter and
-    setter for that property.
-    """
-    c = Code()
-    override = self._GetOverride([type_.name, prop.name, '.get'],
-                                 document_with=prop)
-    c.Cblock(override if override is not None
-             else self._GenerateGetter(type_, prop))
-    override = self._GetOverride([type_.name, prop.name, '.set'])
-    c.Cblock(override if override is not None
-             else self._GenerateSetter(type_, prop))
-    return c
-
-  def _GenerateGetter(self, type_, prop):
-    """Given a Type and Property, returns the Code object for the getter for
-    that property.
-
-    Also adds the documentation for this property before the method.
-    """
-    c = Code()
-    c.Concat(self._GenerateDocumentation(prop))
-
-    type_name = self._GetDartType(prop.type_)
-    if (self._IsBaseType(prop.type_)):
-      c.Append("%s get %s => JS('%s', '#.%s', this._jsObject);" %
-          (type_name, prop.name, type_name, prop.name))
-    elif self._IsSerializableObjectType(prop.type_):
-      c.Append("%s get %s => new %s._proxy(JS('', '#.%s', "
-               "this._jsObject));" %
-          (type_name, prop.name, type_name, prop.name))
-    elif self._IsListOfSerializableObjects(prop.type_):
-      (c.Sblock('%s get %s {' % (type_name, prop.name))
-        .Append('%s __proxy_%s = new %s();' % (type_name, prop.name,
-                                               type_name))
-        .Append("int count = JS('int', '#.%s.length', this._jsObject);" %
-            prop.name)
-        .Sblock("for (int i = 0; i < count; i++) {")
-        .Append("var item = JS('', '#.%s[#]', this._jsObject, i);" % prop.name)
-        .Append('__proxy_%s.add(new %s._proxy(item));' % (prop.name,
-            self._GetDartType(prop.type_.item_type)))
-        .Eblock('}')
-        .Append('return __proxy_%s;' % prop.name)
-        .Eblock('}')
-      )
-    elif self._IsObjectType(prop.type_):
-      # TODO(sashab): Think of a way to serialize generic Dart objects.
-      if type_name in self._types:
-        c.Append("%s get %s => new %s._proxy(JS('%s', '#.%s', "
-                 "this._jsObject));" %
-            (type_name, prop.name, type_name, type_name, prop.name))
-      else:
-        c.Append("%s get %s => JS('%s', '#.%s', this._jsObject);" %
-            (type_name, prop.name, type_name, prop.name))
-    else:
-      raise Exception(
-          "Could not generate wrapper for %s.%s: unserializable type %s" %
-          (type_.name, prop.name, type_name)
-      )
-    return c
-
-  def _GenerateSetter(self, type_, prop):
-    """Given a Type and Property, returns the Code object for the setter for
-    that property.
-    """
-    c = Code()
-    type_name = self._GetDartType(prop.type_)
-    wrapped_name = prop.name
-    if not self._IsBaseType(prop.type_):
-      wrapped_name = 'convertArgument(%s)' % prop.name
-
-    (c.Sblock("void set %s(%s %s) {" % (prop.name, type_name, prop.name))
-      .Append("JS('void', '#.%s = #', this._jsObject, %s);" %
-        (prop.name, wrapped_name))
-      .Eblock("}")
-    )
-    return c
-
-  def _GenerateDocumentation(self, prop):
-    """Given an object, generates the documentation for this object (as a
-    code string) and returns the Code object.
-
-    Returns an empty code object if the object has no documentation.
-
-    Uses triple-quotes for the string.
-    """
-    c = Code()
-    if prop.description is not None:
-      for line in prop.description.split('\n'):
-        c.Comment(line, comment_prefix='/// ')
-    return c
-
-  def _GenerateFunction(self, f):
-    """Returns the Code object for the given function.
-    """
-    c = Code()
-    c.Concat(self._GenerateDocumentation(f))
-
-    if not self._NeedsProxiedCallback(f):
-      c.Append("%s => %s;" % (self._GenerateFunctionSignature(f),
-                              self._GenerateProxyCall(f)))
-      return c
-
-    (c.Sblock("%s {" % self._GenerateFunctionSignature(f))
-      .Concat(self._GenerateProxiedFunction(f.callback, f.callback.name))
-      .Append('%s;' % self._GenerateProxyCall(f))
-      .Eblock('}')
-    )
-
-    return c
-
-  def _GenerateProxiedFunction(self, f, callback_name):
-    """Given a function (assumed to be a callback), generates the proxied
-    version of this function, which calls |callback_name| if it is defined.
-
-    Returns a Code object.
-    """
-    c = Code()
-    proxied_params = []
-    # A list of Properties, containing List<*> objects that need proxying for
-    # their members (by copying out each member and proxying it).
-    lists_to_proxy = []
-    for p in f.params:
-      if self._IsBaseType(p.type_):
-        proxied_params.append(p.name)
-      elif self._IsSerializableObjectType(p.type_):
-        proxied_params.append('new %s._proxy(%s)' % (
-            self._GetDartType(p.type_), p.name))
-      elif self._IsListOfSerializableObjects(p.type_):
-        proxied_params.append('__proxy_%s' % p.name)
-        lists_to_proxy.append(p)
-      elif self._IsObjectType(p.type_):
-        # TODO(sashab): Find a way to build generic JS objects back in Dart.
-        proxied_params.append('%s' % p.name)
-      elif p.type_.property_type is PropertyType.ARRAY:
-        # TODO(sashab): This might be okay - what if this is a list of
-        # FileEntry elements? In this case, a basic list will proxy the objects
-        # fine.
-        proxied_params.append('%s' % p.name)
-      else:
-        raise Exception(
-            "Cannot automatically create proxy; can't wrap %s, type %s" % (
-                self._GenerateFunctionSignature(f), self._GetDartType(p.type_)))
-
-    (c.Sblock("void __proxy_callback(%s) {" % ', '.join(p.name for p in
-                                               f.params))
-      .Sblock('if (%s != null) {' % callback_name)
-    )
-
-    # Add the proxied lists.
-    for list_to_proxy in lists_to_proxy:
-      (c.Append("%s __proxy_%s = new %s();" % (
-                    self._GetDartType(list_to_proxy.type_),
-                    list_to_proxy.name,
-                    self._GetDartType(list_to_proxy.type_)))
-        .Sblock("for (var o in %s) {" % list_to_proxy.name)
-        .Append('__proxy_%s.add(new %s._proxy(o));' % (list_to_proxy.name,
-            self._GetDartType(list_to_proxy.type_.item_type)))
-        .Eblock("}")
-      )
-
-    (c.Append("%s(%s);" % (callback_name, ', '.join(proxied_params)))
-      .Eblock('}')
-      .Eblock('}')
-    )
-    return c
-
-  def _NeedsProxiedCallback(self, f):
-    """Given a function, returns True if this function's callback needs to be
-    proxied, False if not.
-
-    Function callbacks need to be proxied if they have at least one
-    non-base-type parameter.
-    """
-    return f.callback and self._NeedsProxy(f.callback)
-
-  def _NeedsProxy(self, f):
-    """Given a function, returns True if it needs to be proxied, False if not.
-
-    A function needs to be proxied if any of its members are non-base types.
-    This means that, when the function object is passed to Javascript, it
-    needs to be wrapped in a "proxied" call that converts the JS inputs to Dart
-    objects explicitly, before calling the real function with these new objects.
-    """
-    return any(not self._IsBaseType(p.type_) for p in f.params)
-
-  def _GenerateProxyCall(self, function, call_target='this._jsObject'):
-    """Given a function, generates the code to call that function via JS().
-    Returns a string.
-
-    |call_target| is the name of the object to call the function on. The default
-    is this._jsObject.
-
-    e.g.
-        JS('void', '#.resizeTo(#, #)', this._jsObject, width, height)
-        JS('void', '#.setBounds(#)', this._jsObject, convertArgument(bounds))
-    """
-    n_params = len(function.params)
-    if function.callback:
-      n_params += 1
-
-    return_type_str = self._GetDartType(function.returns)
-    params = []
-
-    # If this object is serializable, don't convert the type from JS - pass the
-    # JS object straight into the proxy.
-    if self._IsSerializableObjectType(function.returns):
-      params.append("''")
-    else:
-      params.append("'%s'" % return_type_str)
-
-    params.append("'#.%s(%s)'" % (function.name, ', '.join(['#'] * n_params)))
-    params.append(call_target)
-
-    for param in function.params:
-      if not self._IsBaseType(param.type_):
-        params.append('convertArgument(%s)' % param.name)
-      else:
-        params.append(param.name)
-    if function.callback:
-      # If this isn't a base type, we need a proxied callback.
-      callback_name = function.callback.name
-      if self._NeedsProxiedCallback(function):
-        callback_name = "__proxy_callback"
-      params.append('convertDartClosureToJS(%s, %s)' % (callback_name,
-                    len(function.callback.params)))
-
-    # If the object is serializable, call the proxy constructor for this type.
-    proxy_call = 'JS(%s)' % ', '.join(params)
-    if self._IsSerializableObjectType(function.returns):
-      proxy_call = 'new %s._proxy(%s)' % (return_type_str, proxy_call)
-
-    return proxy_call
-
-  def _GenerateEvent(self, event):
-    """Given a Function object, returns the Code with the .dart for this event,
-    represented by the function.
-
-    All events extend the Event base type.
-    """
-    c = Code()
-
-    # Add documentation for this event.
-    (c.Concat(self._GenerateDocumentation(event))
-      .Sblock('class Event_%(event_name)s extends Event {')
-    )
-
-    # If this event needs a proxy, all calls need to be proxied.
-    needs_proxy = self._NeedsProxy(event)
-
-    # Override Event callback type definitions.
-    for ret_type, event_func in (('void', 'addListener'),
-                                 ('void', 'removeListener'),
-                                 ('bool', 'hasListener')):
-      param_list = self._GenerateParameterList(event.params, event.callback,
-                                               convert_optional=True)
-      if needs_proxy:
-        (c.Sblock('%s %s(void callback(%s)) {' % (ret_type, event_func,
-                                                 param_list))
-          .Concat(self._GenerateProxiedFunction(event, 'callback'))
-          .Append('super.%s(__proxy_callback);' % event_func)
-          .Eblock('}')
-        )
-      else:
-        c.Append('%s %s(void callback(%s)) => super.%s(callback);' %
-            (ret_type, event_func, param_list, event_func))
-      c.Append()
-
-    # Generate the constructor.
-    (c.Append('Event_%(event_name)s(jsObject) : '
-              'super._(jsObject, %(param_num)d);')
-      .Eblock('}')
-      .Substitute({
-        'event_name': self._namespace.unix_name + '_' + event.name,
-        'param_num': len(event.params)
-      })
-    )
-
-    return c
-
-  def _GenerateMainClass(self):
-    """Generates the main class for this file, which links to all functions
-    and events.
-
-    Returns a code object.
-    """
-    c = Code()
-    (c.Sblock('class API_%s {' % self._namespace.unix_name)
-      .Append('/*')
-      .Append(' * API connection')
-      .Append(' */')
-      .Append('Object _jsObject;')
-    )
-
-    # Add events.
-    if self._namespace.events:
-      (c.Append()
-        .Append('/*')
-        .Append(' * Events')
-        .Append(' */')
-      )
-    for event_name in self._namespace.events:
-      c.Append('Event_%s_%s %s;' % (self._namespace.unix_name, event_name,
-                                    event_name))
-
-    # Add functions.
-    if self._namespace.functions:
-      (c.Append()
-        .Append('/*')
-        .Append(' * Functions')
-        .Append(' */')
-      )
-    for function in self._namespace.functions.values():
-      # Check for custom dart for this whole property.
-      override = self._GetOverride([function.name], document_with=function)
-      c.Cblock(override if override is not None
-               else self._GenerateFunction(function))
-
-    # Add the constructor.
-    c.Sblock('API_%s(this._jsObject) {' % self._namespace.unix_name)
-
-    # Add events to constructor.
-    for event_name in self._namespace.events:
-      c.Append("%s = new Event_%s_%s(JS('', '#.%s', this._jsObject));" %
-        (event_name, self._namespace.unix_name, event_name, event_name))
-
-    (c.Eblock('}')
-      .Eblock('}')
-    )
-    return c
-
-  def _GeneratePropertySignature(self, prop):
-    """Given a property, returns a signature for that property.
-    Recursively generates the signature for callbacks.
-    Returns a String for the given property.
-
-    e.g.
-      bool x
-      void onClosed()
-      void doSomething(bool x, void callback([String x]))
-    """
-    if self._IsFunction(prop.type_):
-      return self._GenerateFunctionSignature(prop.type_.function)
-    return '%(type)s %(name)s' % {
-               'type': self._GetDartType(prop.type_),
-               'name': prop.simple_name
-           }
-
-  def _GenerateFunctionSignature(self, function, convert_optional=False):
-    """Given a function object, returns the signature for that function.
-    Recursively generates the signature for callbacks.
-    Returns a String for the given function.
-
-    If convert_optional is True, changes optional parameters to be required.
-
-    e.g.
-      void onClosed()
-      bool isOpen([String type])
-      void doSomething(bool x, void callback([String x]))
-    """
-    sig = '%(return_type)s %(name)s(%(params)s)'
-
-    if function.returns:
-      return_type = self._GetDartType(function.returns)
-    else:
-      return_type = 'void'
-
-    return sig % {
-        'return_type': return_type,
-        'name': function.simple_name,
-        'params': self._GenerateParameterList(function.params,
-                                              function.callback,
-                                              convert_optional=convert_optional)
-    }
-
-  def _GenerateParameterList(self,
-                             params,
-                             callback=None,
-                             convert_optional=False):
-    """Given a list of function parameters, generates their signature (as a
-    string).
-
-    e.g.
-      [String type]
-      bool x, void callback([String x])
-
-    If convert_optional is True, changes optional parameters to be required.
-    Useful for callbacks, where optional parameters are treated as required.
-    """
-    # Params lists (required & optional), to be joined with commas.
-    # TODO(sashab): Don't assume optional params always come after required
-    # ones.
-    params_req = []
-    params_opt = []
-    for param in params:
-      p_sig = self._GeneratePropertySignature(param)
-      if param.optional and not convert_optional:
-        params_opt.append(p_sig)
-      else:
-        params_req.append(p_sig)
-
-    # Add the callback, if it exists.
-    if callback:
-      c_sig = self._GenerateFunctionSignature(callback, convert_optional=True)
-      if callback.optional:
-        params_opt.append(c_sig)
-      else:
-        params_req.append(c_sig)
-
-    # Join the parameters with commas.
-    # Optional parameters have to be in square brackets, e.g.:
-    #
-    #  required params | optional params |     output
-    #        []        |        []       |       ''
-    #      [x, y]      |        []       |     'x, y'
-    #        []        |      [a, b]     |    '[a, b]'
-    #      [x, y]      |      [a, b]     | 'x, y, [a, b]'
-    if params_opt:
-      params_opt[0] = '[%s' % params_opt[0]
-      params_opt[-1] = '%s]' % params_opt[-1]
-    param_sets = [', '.join(params_req), ', '.join(params_opt)]
-
-    # The 'if p' part here is needed to prevent commas where there are no
-    # parameters of a certain type.
-    # If there are no optional parameters, this prevents a _trailing_ comma,
-    # e.g. '(x, y,)'. Similarly, if there are no required parameters, this
-    # prevents a leading comma, e.g. '(, [a, b])'.
-    return ', '.join(p for p in param_sets if p)
-
-  def _GetOverride(self, key_chain, document_with=None):
-    """Given a list of keys, joins them with periods and searches for them in
-    the custom dart overrides.
-    If there is an override for that key, finds the override code and returns
-    the Code object. If not, returns None.
-
-    If document_with is not None, adds the documentation for this property
-    before the override code.
-    """
-    c = Code()
-    contents = self._type_overrides.get('.'.join(key_chain))
-    if contents is None:
-      return None
-
-    if document_with is not None:
-      c.Concat(self._GenerateDocumentation(document_with))
-    for line in contents.strip('\n').split('\n'):
-      c.Append(line)
-    return c
-
-  def _AddPrefix(self, name):
-    """Given the name of a type, prefixes the namespace (as camelcase) and
-    returns the new name.
-    """
-    # TODO(sashab): Split the dart library into multiple files, avoiding the
-    # need for this prefixing.
-    return ('%s%s' % (
-        ''.join(s.capitalize() for s in self._namespace.name.split('.')),
-        name))
-
-  def _IsFunction(self, type_):
-    """Given a model.Type, returns whether this type is a function.
-    """
-    return type_.property_type == PropertyType.FUNCTION
-
-  def _IsSerializableObjectType(self, type_):
-    """Given a model.Type, returns whether this type is a serializable object.
-    Serializable objects are custom types defined in this namespace.
-
-    If this object is a reference to something not in this namespace, assumes
-    its a serializable object.
-    """
-    if type_ is None:
-      return False
-    if type_.property_type is PropertyType.CHOICES:
-      return all(self._IsSerializableObjectType(c) for c in type_.choices)
-    if type_.property_type is PropertyType.REF:
-      if type_.ref_type in self._types:
-        return self._IsObjectType(self._types[type_.ref_type])
-      return True
-    if (type_.property_type == PropertyType.OBJECT
-        and type_.instance_of in self._types):
-      return self._IsObjectType(self._types[type_.instance_of])
-    return False
-
-  def _IsObjectType(self, type_):
-    """Given a model.Type, returns whether this type is an object.
-    """
-    return (self._IsSerializableObjectType(type_)
-            or type_.property_type in [PropertyType.OBJECT, PropertyType.ANY])
-
-  def _IsListOfSerializableObjects(self, type_):
-    """Given a model.Type, returns whether this type is a list of serializable
-    objects (or regular objects, if this list is treated as a type - in this
-    case, the item type was defined inline).
-
-    If this type is a reference to something not in this namespace, assumes
-    it is not a list of serializable objects.
-    """
-    if type_.property_type is PropertyType.CHOICES:
-      return all(self._IsListOfSerializableObjects(c) for c in type_.choices)
-    if type_.property_type is PropertyType.REF:
-      if type_.ref_type in self._types:
-        return self._IsListOfSerializableObjects(self._types[type_.ref_type])
-      return False
-    return (type_.property_type is PropertyType.ARRAY and
-        (self._IsSerializableObjectType(type_.item_type)))
-
-  def _IsListOfBaseTypes(self, type_):
-    """Given a model.Type, returns whether this type is a list of base type
-    objects (PropertyType.REF types).
-    """
-    if type_.property_type is PropertyType.CHOICES:
-      return all(self._IsListOfBaseTypes(c) for c in type_.choices)
-    return (type_.property_type is PropertyType.ARRAY and
-            self._IsBaseType(type_.item_type))
-
-  def _IsBaseType(self, type_):
-    """Given a model.type_, returns whether this type is a base type
-    (string, number, boolean, or a list of these).
-
-    If type_ is a Choices object, returns True if all possible choices are base
-    types.
-    """
-    # TODO(sashab): Remove 'Choices' as a base type once they are wrapped in
-    # native Dart classes.
-    if type_.property_type is PropertyType.CHOICES:
-      return all(self._IsBaseType(c) for c in type_.choices)
-    return (
-        (self._GetDartType(type_) in ['bool', 'num', 'int', 'double', 'String'])
-        or (type_.property_type is PropertyType.ARRAY
-            and self._IsBaseType(type_.item_type))
-    )
-
-  def _GetDartType(self, type_):
-    """Given a model.Type object, returns its type as a Dart string.
-    """
-    if type_ is None:
-      return 'void'
-
-    prop_type = type_.property_type
-    if prop_type is PropertyType.REF:
-      if type_.ref_type in self._types:
-        return self._GetDartType(self._types[type_.ref_type])
-      # TODO(sashab): If the type is foreign, it might have to be imported.
-      return StripNamespace(type_.ref_type)
-    elif prop_type is PropertyType.BOOLEAN:
-      return 'bool'
-    elif prop_type is PropertyType.INTEGER:
-      return 'int'
-    elif prop_type is PropertyType.INT64:
-      return 'num'
-    elif prop_type is PropertyType.DOUBLE:
-      return 'double'
-    elif prop_type is PropertyType.STRING:
-      return 'String'
-    elif prop_type is PropertyType.ENUM:
-      return 'String'
-    elif prop_type is PropertyType.CHOICES:
-      # TODO(sashab): Think of a nice way to generate code for Choices objects
-      # in Dart.
-      return 'Object'
-    elif prop_type is PropertyType.ANY:
-      return 'Object'
-    elif prop_type is PropertyType.OBJECT:
-      # TODO(sashab): type_.name is the name of the function's parameter for
-      # inline types defined in functions. Think of a way to generate names
-      # for this, or remove all inline type definitions at the start.
-      if type_.instance_of is not None:
-        return type_.instance_of
-      if not isinstance(type_.parent, Function):
-        return self._AddPrefix(type_.name)
-      return 'Object'
-    elif prop_type is PropertyType.FUNCTION:
-      return 'Function'
-    elif prop_type is PropertyType.ARRAY:
-      return 'List<%s>' % self._GetDartType(type_.item_type)
-    elif prop_type is PropertyType.BINARY:
-      return 'String'
-    else:
-      raise NotImplementedError(prop_type)
-
diff --git a/tools/json_schema_compiler/dart_generator_test.py b/tools/json_schema_compiler/dart_generator_test.py
deleted file mode 100755
index 2005e7e..0000000
--- a/tools/json_schema_compiler/dart_generator_test.py
+++ /dev/null
@@ -1,81 +0,0 @@
-#!/usr/bin/env python
-# 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.
-
-import os
-import sys
-import unittest
-
-from compiler import GenerateSchema
-
-# If --rebase is passed to this test, this is set to True, indicating the test
-# output should be re-generated for each test (rather than running the tests
-# themselves).
-REBASE_MODE = False
-
-# The directory containing the input and expected output files corresponding
-# to each test name.
-TESTS_DIR = 'dart_test'
-
-class DartTest(unittest.TestCase):
-
-  def _RunTest(self, test_filename):
-    '''Given the name of a test, runs compiler.py on the file:
-      TESTS_DIR/test_filename.idl
-    and compares it to the output in the file:
-      TESTS_DIR/test_filename.dart
-    '''
-    file_rel = os.path.join(TESTS_DIR, test_filename)
-
-    output_dir = None
-    if REBASE_MODE:
-      output_dir = TESTS_DIR
-    output_code = GenerateSchema('dart', ['%s.idl' % file_rel], TESTS_DIR,
-                                 output_dir, '', None, None, [])
-
-    if not REBASE_MODE:
-      with open('%s.dart' % file_rel) as f:
-        expected_output = f.read()
-      # Remove the first line of the output code (as it contains the filename).
-      # Also remove all blank lines, ignoring them from the comparison.
-      # Compare with lists instead of strings for clearer diffs (especially with
-      # whitespace) when a test fails.
-      self.assertEqual([l for l in expected_output.split('\n') if l],
-                       [l for l in output_code.split('\n')[1:] if l])
-
-  def setUp(self):
-    # Increase the maximum diff amount to see the full diff on a failed test.
-    self.maxDiff = 2000
-
-  def testComments(self):
-    self._RunTest('comments')
-
-  def testDictionaries(self):
-    self._RunTest('dictionaries')
-
-  def testEmptyNamespace(self):
-    self._RunTest('empty_namespace')
-
-  def testEmptyType(self):
-    self._RunTest('empty_type')
-
-  def testEvents(self):
-    self._RunTest('events')
-
-  def testBasicFunction(self):
-    self._RunTest('functions')
-
-  def testOpratableType(self):
-    self._RunTest('operatable_type')
-
-  def testTags(self):
-    self._RunTest('tags')
-
-
-if __name__ == '__main__':
-  if '--rebase' in sys.argv:
-    print "Running in rebase mode."
-    REBASE_MODE = True
-    sys.argv.remove('--rebase')
-  unittest.main()
diff --git a/tools/json_schema_compiler/dart_test/comments.dart b/tools/json_schema_compiler/dart_test/comments.dart
deleted file mode 100644
index 6c30bb7..0000000
--- a/tools/json_schema_compiler/dart_test/comments.dart
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-// Generated from namespace: comments
-
-part of chrome;
-/**
- * Functions
- */
-
-class API_comments {
-  /*
-   * API connection
-   */
-  Object _jsObject;
-
-  /*
-   * Functions
-   */
-  /// <p>There's a blank line at the start of this comment.</p><p>Documentation
-  /// for basicFunction. BasicFunction() is a great function. There is a newline
-  /// after this.</p><p>It works like so:        +-----+        |     |     +--+
-  ///       |     |     |  |        +-----+ --> +--+</p><p>Some other stuff here.
-  ///    This paragraph starts with whitespace.    Overall, its a great function.
-  /// There's also a blank line at the end of this comment.</p>
-  void basicFunction() => JS('void', '#.basicFunction()', this._jsObject);
-
-  API_comments(this._jsObject) {
-  }
-}
diff --git a/tools/json_schema_compiler/dart_test/comments.idl b/tools/json_schema_compiler/dart_test/comments.idl
deleted file mode 100644
index 7ac1474..0000000
--- a/tools/json_schema_compiler/dart_test/comments.idl
+++ /dev/null
@@ -1,32 +0,0 @@
-// 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.
-
-// This comment is for the comments namespace.
-namespace comments {
-  // This comments the "Functions" block, and should be ignored.
-  interface Functions {
-    // This comment is separated by at least one blank line from the start of
-    // the function, and should be ignored.
-  
-    //
-    // There's a blank line at the start of this comment.
-    //
-    // Documentation for basicFunction.
-    // BasicFunction() is a great function.
-    // There is a newline after this.
-    //
-    // It works like so:
-    //        +-----+
-    //        |     |     +--+
-    //        |     |     |  |
-    //        +-----+ --> +--+
-    //
-    // Some other stuff here.
-    //    This paragraph starts with whitespace.
-    //    Overall, its a great function.
-    // There's also a blank line at the end of this comment.
-    //
-    static void basicFunction();
-  };
-};
diff --git a/tools/json_schema_compiler/dart_test/dictionaries.dart b/tools/json_schema_compiler/dart_test/dictionaries.dart
deleted file mode 100644
index d6b6874..0000000
--- a/tools/json_schema_compiler/dart_test/dictionaries.dart
+++ /dev/null
@@ -1,235 +0,0 @@
-// Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-// Generated from namespace: dictionaries
-
-part of chrome;
-
-/**
- * Types
- */
-
-class DictionariesInnerType extends ChromeObject {
-  /*
-   * Public constructor
-   */
-  DictionariesInnerType({String s, int b, int i, int l, double d, FileEntry f, String os, int ob, int oi, int ol, double od, FileEntry of}) {
-    if (s != null)
-      this.s = s;
-    if (b != null)
-      this.b = b;
-    if (i != null)
-      this.i = i;
-    if (l != null)
-      this.l = l;
-    if (d != null)
-      this.d = d;
-    if (f != null)
-      this.f = f;
-    if (os != null)
-      this.os = os;
-    if (ob != null)
-      this.ob = ob;
-    if (oi != null)
-      this.oi = oi;
-    if (ol != null)
-      this.ol = ol;
-    if (od != null)
-      this.od = od;
-    if (of != null)
-      this.of = of;
-  }
-
-  /*
-   * Private constructor
-   */
-  DictionariesInnerType._proxy(_jsObject) : super._proxy(_jsObject);
-
-  /*
-   * Public accessors
-   */
-  /// Documentation for the String s.
-  String get s => JS('String', '#.s', this._jsObject);
-
-  void set s(String s) {
-    JS('void', '#.s = #', this._jsObject, s);
-  }
-
-  /// Documentation for the boolean b.
-  int get b => JS('int', '#.b', this._jsObject);
-
-  void set b(int b) {
-    JS('void', '#.b = #', this._jsObject, b);
-  }
-
-  /// Documentation for the int i.
-  int get i => JS('int', '#.i', this._jsObject);
-
-  void set i(int i) {
-    JS('void', '#.i = #', this._jsObject, i);
-  }
-
-  /// Documentation for the long l.
-  int get l => JS('int', '#.l', this._jsObject);
-
-  void set l(int l) {
-    JS('void', '#.l = #', this._jsObject, l);
-  }
-
-  /// Documentation for the double d.
-  double get d => JS('double', '#.d', this._jsObject);
-
-  void set d(double d) {
-    JS('void', '#.d = #', this._jsObject, d);
-  }
-
-  /// Documentation for the file entry f.
-  FileEntry get f => JS('FileEntry', '#.f', this._jsObject);
-
-  void set f(FileEntry f) {
-    JS('void', '#.f = #', this._jsObject, convertArgument(f));
-  }
-
-  /// Documentation for the optional String s.
-  String get os => JS('String', '#.os', this._jsObject);
-
-  void set os(String os) {
-    JS('void', '#.os = #', this._jsObject, os);
-  }
-
-  /// Documentation for the optional boolean ob.
-  int get ob => JS('int', '#.ob', this._jsObject);
-
-  void set ob(int ob) {
-    JS('void', '#.ob = #', this._jsObject, ob);
-  }
-
-  /// Documentation for the optional int i.
-  int get oi => JS('int', '#.oi', this._jsObject);
-
-  void set oi(int oi) {
-    JS('void', '#.oi = #', this._jsObject, oi);
-  }
-
-  /// Documentation for the optional long l.
-  int get ol => JS('int', '#.ol', this._jsObject);
-
-  void set ol(int ol) {
-    JS('void', '#.ol = #', this._jsObject, ol);
-  }
-
-  /// Documentation for the optional double d.
-  double get od => JS('double', '#.od', this._jsObject);
-
-  void set od(double od) {
-    JS('void', '#.od = #', this._jsObject, od);
-  }
-
-  /// Documentation for the optional file entry f.
-  FileEntry get of => JS('FileEntry', '#.of', this._jsObject);
-
-  void set of(FileEntry of) {
-    JS('void', '#.of = #', this._jsObject, convertArgument(of));
-  }
-
-}
-
-class DictionariesOuterType extends ChromeObject {
-  /*
-   * Public constructor
-   */
-  DictionariesOuterType({List<DictionariesInnerType> items, List<DictionariesInnerType> oitems}) {
-    if (items != null)
-      this.items = items;
-    if (oitems != null)
-      this.oitems = oitems;
-  }
-
-  /*
-   * Private constructor
-   */
-  DictionariesOuterType._proxy(_jsObject) : super._proxy(_jsObject);
-
-  /*
-   * Public accessors
-   */
-  /// Documentation for the array of InnerTypes items.
-  List<DictionariesInnerType> get items {
-    List<DictionariesInnerType> __proxy_items = new List<DictionariesInnerType>();
-    int count = JS('int', '#.items.length', this._jsObject);
-    for (int i = 0; i < count; i++) {
-      var item = JS('', '#.items[#]', this._jsObject, i);
-      __proxy_items.add(new DictionariesInnerType._proxy(item));
-    }
-    return __proxy_items;
-  }
-
-  void set items(List<DictionariesInnerType> items) {
-    JS('void', '#.items = #', this._jsObject, convertArgument(items));
-  }
-
-  /// Documentation for the optional array of Inner Types oitems.
-  List<DictionariesInnerType> get oitems {
-    List<DictionariesInnerType> __proxy_oitems = new List<DictionariesInnerType>();
-    int count = JS('int', '#.oitems.length', this._jsObject);
-    for (int i = 0; i < count; i++) {
-      var item = JS('', '#.oitems[#]', this._jsObject, i);
-      __proxy_oitems.add(new DictionariesInnerType._proxy(item));
-    }
-    return __proxy_oitems;
-  }
-
-  void set oitems(List<DictionariesInnerType> oitems) {
-    JS('void', '#.oitems = #', this._jsObject, convertArgument(oitems));
-  }
-
-}
-
-class DictionariesComplexType extends ChromeObject {
-  /*
-   * Public constructor
-   */
-  DictionariesComplexType({int i, DictionariesComplexType c}) {
-    if (i != null)
-      this.i = i;
-    if (c != null)
-      this.c = c;
-  }
-
-  /*
-   * Private constructor
-   */
-  DictionariesComplexType._proxy(_jsObject) : super._proxy(_jsObject);
-
-  /*
-   * Public accessors
-   */
-  /// Documentation for the int i.
-  int get i => JS('int', '#.i', this._jsObject);
-
-  void set i(int i) {
-    JS('void', '#.i = #', this._jsObject, i);
-  }
-
-  /// Documentation for the ComplexType c.
-  DictionariesComplexType get c => new DictionariesComplexType._proxy(JS('', '#.c', this._jsObject));
-
-  void set c(DictionariesComplexType c) {
-    JS('void', '#.c = #', this._jsObject, convertArgument(c));
-  }
-
-}
-
-/**
- * Functions
- */
-
-class API_dictionaries {
-  /*
-   * API connection
-   */
-  Object _jsObject;
-  API_dictionaries(this._jsObject) {
-  }
-}
diff --git a/tools/json_schema_compiler/dart_test/dictionaries.idl b/tools/json_schema_compiler/dart_test/dictionaries.idl
deleted file mode 100644
index 1eb9e25..0000000
--- a/tools/json_schema_compiler/dart_test/dictionaries.idl
+++ /dev/null
@@ -1,61 +0,0 @@
-// 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.
-
-// This comment is for the dictionaries namespace.
-namespace dictionaries {
-  // Documentation for ComplexType.
-  dictionary InnerType {
-    // Documentation for the String s.
-    DOMString s;
-
-    // Documentation for the boolean b.
-    int b;
-
-    // Documentation for the int i.
-    int i;
-
-    // Documentation for the long l.
-    long l;
-
-    // Documentation for the double d.
-    double d;
-
-    // Documentation for the file entry f.
-    [instanceOf=FileEntry] object f;
-
-    // Documentation for the optional String s.
-    DOMString? os;
-
-    // Documentation for the optional boolean ob.
-    int ob;
-
-    // Documentation for the optional int i.
-    int? oi;
-
-    // Documentation for the optional long l.
-    long? ol;
-
-    // Documentation for the optional double d.
-    double? od;
-
-    // Documentation for the optional file entry f.
-    [instanceOf=FileEntry] object? of;
-  };
-
-  dictionary OuterType {
-    // Documentation for the array of InnerTypes items.
-    InnerType[] items;
-
-    // Documentation for the optional array of Inner Types oitems.
-    InnerType[]? oitems;
-  };
-
-  dictionary ComplexType {
-    // Documentation for the int i.
-    int i;
-
-    // Documentation for the ComplexType c.
-    ComplexType c;
-  };
-};
diff --git a/tools/json_schema_compiler/dart_test/empty_namespace.dart b/tools/json_schema_compiler/dart_test/empty_namespace.dart
deleted file mode 100644
index f6e48be..0000000
--- a/tools/json_schema_compiler/dart_test/empty_namespace.dart
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-// Generated from namespace: empty_namespace
-
-part of chrome;
-/**
- * Functions
- */
-
-class API_empty_namespace {
-  /*
-   * API connection
-   */
-  Object _jsObject;
-  API_empty_namespace(this._jsObject) {
-  }
-}
diff --git a/tools/json_schema_compiler/dart_test/empty_namespace.idl b/tools/json_schema_compiler/dart_test/empty_namespace.idl
deleted file mode 100644
index 824de2d..0000000
--- a/tools/json_schema_compiler/dart_test/empty_namespace.idl
+++ /dev/null
@@ -1,7 +0,0 @@
-// 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 empty comment is required for an empty namespace.
-namespace empty_namespace {
-};
diff --git a/tools/json_schema_compiler/dart_test/empty_type.dart b/tools/json_schema_compiler/dart_test/empty_type.dart
deleted file mode 100644
index 29e8df9..0000000
--- a/tools/json_schema_compiler/dart_test/empty_type.dart
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-// Generated from namespace: empty_type
-
-part of chrome;
-
-/**
- * Types
- */
-
-class Empty_typeEmptyType extends ChromeObject {
-  /*
-   * Public constructor
-   */
-  Empty_typeEmptyType({}) {
-  }
-
-  /*
-   * Private constructor
-   */
-  Empty_typeEmptyType._proxy(_jsObject) : super._proxy(_jsObject);
-}
-
-/**
- * Functions
- */
-
-class API_empty_type {
-  /*
-   * API connection
-   */
-  Object _jsObject;
-  API_empty_type(this._jsObject) {
-  }
-}
diff --git a/tools/json_schema_compiler/dart_test/empty_type.idl b/tools/json_schema_compiler/dart_test/empty_type.idl
deleted file mode 100644
index 9d7de6f..0000000
--- a/tools/json_schema_compiler/dart_test/empty_type.idl
+++ /dev/null
@@ -1,10 +0,0 @@
-// 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.
-
-// Namespace-level comment for EmptyType.
-namespace empty_type {
-  // Documentation for EmptyType.
-  dictionary EmptyType {
-  };
-};
diff --git a/tools/json_schema_compiler/dart_test/events.dart b/tools/json_schema_compiler/dart_test/events.dart
deleted file mode 100644
index 14cb19b..0000000
--- a/tools/json_schema_compiler/dart_test/events.dart
+++ /dev/null
@@ -1,282 +0,0 @@
-// Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-// Generated from namespace: events
-
-part of chrome;
-
-/**
- * Types
- */
-
-class EventsEventArgumentElement extends ChromeObject {
-  /*
-   * Public constructor
-   */
-  EventsEventArgumentElement({String elementStringArg}) {
-    if (elementStringArg != null)
-      this.elementStringArg = elementStringArg;
-  }
-
-  /*
-   * Private constructor
-   */
-  EventsEventArgumentElement._proxy(_jsObject) : super._proxy(_jsObject);
-
-  /*
-   * Public accessors
-   */
-  String get elementStringArg => JS('String', '#.elementStringArg', this._jsObject);
-
-  void set elementStringArg(String elementStringArg) {
-    JS('void', '#.elementStringArg = #', this._jsObject, elementStringArg);
-  }
-
-}
-
-class EventsEventArgument extends ChromeObject {
-  /*
-   * Public constructor
-   */
-  EventsEventArgument({FileEntry entryArg, String stringArg, int intArg, List<EventsEventArgumentElement> elements, FileEntry optionalEntryArg, String optionalStringArg, int optionalIntArg, List<EventsEventArgumentElement> optionalElements}) {
-    if (entryArg != null)
-      this.entryArg = entryArg;
-    if (stringArg != null)
-      this.stringArg = stringArg;
-    if (intArg != null)
-      this.intArg = intArg;
-    if (elements != null)
-      this.elements = elements;
-    if (optionalEntryArg != null)
-      this.optionalEntryArg = optionalEntryArg;
-    if (optionalStringArg != null)
-      this.optionalStringArg = optionalStringArg;
-    if (optionalIntArg != null)
-      this.optionalIntArg = optionalIntArg;
-    if (optionalElements != null)
-      this.optionalElements = optionalElements;
-  }
-
-  /*
-   * Private constructor
-   */
-  EventsEventArgument._proxy(_jsObject) : super._proxy(_jsObject);
-
-  /*
-   * Public accessors
-   */
-  /// A file entry
-  FileEntry get entryArg => JS('FileEntry', '#.entryArg', this._jsObject);
-
-  void set entryArg(FileEntry entryArg) {
-    JS('void', '#.entryArg = #', this._jsObject, convertArgument(entryArg));
-  }
-
-  /// A string
-  String get stringArg => JS('String', '#.stringArg', this._jsObject);
-
-  void set stringArg(String stringArg) {
-    JS('void', '#.stringArg = #', this._jsObject, stringArg);
-  }
-
-  /// A primitive
-  int get intArg => JS('int', '#.intArg', this._jsObject);
-
-  void set intArg(int intArg) {
-    JS('void', '#.intArg = #', this._jsObject, intArg);
-  }
-
-  /// An array
-  List<EventsEventArgumentElement> get elements {
-    List<EventsEventArgumentElement> __proxy_elements = new List<EventsEventArgumentElement>();
-    int count = JS('int', '#.elements.length', this._jsObject);
-    for (int i = 0; i < count; i++) {
-      var item = JS('', '#.elements[#]', this._jsObject, i);
-      __proxy_elements.add(new EventsEventArgumentElement._proxy(item));
-    }
-    return __proxy_elements;
-  }
-
-  void set elements(List<EventsEventArgumentElement> elements) {
-    JS('void', '#.elements = #', this._jsObject, convertArgument(elements));
-  }
-
-  /// Optional file entry
-  FileEntry get optionalEntryArg => JS('FileEntry', '#.optionalEntryArg', this._jsObject);
-
-  void set optionalEntryArg(FileEntry optionalEntryArg) {
-    JS('void', '#.optionalEntryArg = #', this._jsObject, convertArgument(optionalEntryArg));
-  }
-
-  /// A string
-  String get optionalStringArg => JS('String', '#.optionalStringArg', this._jsObject);
-
-  void set optionalStringArg(String optionalStringArg) {
-    JS('void', '#.optionalStringArg = #', this._jsObject, optionalStringArg);
-  }
-
-  /// A primitive
-  int get optionalIntArg => JS('int', '#.optionalIntArg', this._jsObject);
-
-  void set optionalIntArg(int optionalIntArg) {
-    JS('void', '#.optionalIntArg = #', this._jsObject, optionalIntArg);
-  }
-
-  /// An array
-  List<EventsEventArgumentElement> get optionalElements {
-    List<EventsEventArgumentElement> __proxy_optionalElements = new List<EventsEventArgumentElement>();
-    int count = JS('int', '#.optionalElements.length', this._jsObject);
-    for (int i = 0; i < count; i++) {
-      var item = JS('', '#.optionalElements[#]', this._jsObject, i);
-      __proxy_optionalElements.add(new EventsEventArgumentElement._proxy(item));
-    }
-    return __proxy_optionalElements;
-  }
-
-  void set optionalElements(List<EventsEventArgumentElement> optionalElements) {
-    JS('void', '#.optionalElements = #', this._jsObject, convertArgument(optionalElements));
-  }
-
-}
-
-/**
- * Events
- */
-
-/// Documentation for the first basic event.
-class Event_events_firstBasicEvent extends Event {
-  void addListener(void callback()) => super.addListener(callback);
-
-  void removeListener(void callback()) => super.removeListener(callback);
-
-  bool hasListener(void callback()) => super.hasListener(callback);
-
-  Event_events_firstBasicEvent(jsObject) : super._(jsObject, 0);
-}
-
-/// Documentation for the second basic event.
-class Event_events_secondBasicEvent extends Event {
-  void addListener(void callback()) => super.addListener(callback);
-
-  void removeListener(void callback()) => super.removeListener(callback);
-
-  bool hasListener(void callback()) => super.hasListener(callback);
-
-  Event_events_secondBasicEvent(jsObject) : super._(jsObject, 0);
-}
-
-/// Documentation for an event with a non-optional primitive argument.
-class Event_events_nonOptionalPrimitiveArgEvent extends Event {
-  void addListener(void callback(int argument)) => super.addListener(callback);
-
-  void removeListener(void callback(int argument)) => super.removeListener(callback);
-
-  bool hasListener(void callback(int argument)) => super.hasListener(callback);
-
-  Event_events_nonOptionalPrimitiveArgEvent(jsObject) : super._(jsObject, 1);
-}
-
-/// Documentation for an event with an optional primitive argument.
-class Event_events_optionalPrimitiveArgEvent extends Event {
-  void addListener(void callback(int argument)) => super.addListener(callback);
-
-  void removeListener(void callback(int argument)) => super.removeListener(callback);
-
-  bool hasListener(void callback(int argument)) => super.hasListener(callback);
-
-  Event_events_optionalPrimitiveArgEvent(jsObject) : super._(jsObject, 1);
-}
-
-/// Documentation for an event with a non-optional dictionary argument.
-class Event_events_nonOptionalDictArgEvent extends Event {
-  void addListener(void callback(EventsEventArgument argument)) {
-    void __proxy_callback(argument) {
-      if (callback != null) {
-        callback(new EventsEventArgument._proxy(argument));
-      }
-    }
-    super.addListener(__proxy_callback);
-  }
-
-  void removeListener(void callback(EventsEventArgument argument)) {
-    void __proxy_callback(argument) {
-      if (callback != null) {
-        callback(new EventsEventArgument._proxy(argument));
-      }
-    }
-    super.removeListener(__proxy_callback);
-  }
-
-  bool hasListener(void callback(EventsEventArgument argument)) {
-    void __proxy_callback(argument) {
-      if (callback != null) {
-        callback(new EventsEventArgument._proxy(argument));
-      }
-    }
-    super.hasListener(__proxy_callback);
-  }
-
-  Event_events_nonOptionalDictArgEvent(jsObject) : super._(jsObject, 1);
-}
-
-/// Documentation for an event with a optional dictionary argument.
-class Event_events_optionalDictArgEvent extends Event {
-  void addListener(void callback(EventsEventArgument argument)) {
-    void __proxy_callback(argument) {
-      if (callback != null) {
-        callback(new EventsEventArgument._proxy(argument));
-      }
-    }
-    super.addListener(__proxy_callback);
-  }
-
-  void removeListener(void callback(EventsEventArgument argument)) {
-    void __proxy_callback(argument) {
-      if (callback != null) {
-        callback(new EventsEventArgument._proxy(argument));
-      }
-    }
-    super.removeListener(__proxy_callback);
-  }
-
-  bool hasListener(void callback(EventsEventArgument argument)) {
-    void __proxy_callback(argument) {
-      if (callback != null) {
-        callback(new EventsEventArgument._proxy(argument));
-      }
-    }
-    super.hasListener(__proxy_callback);
-  }
-
-  Event_events_optionalDictArgEvent(jsObject) : super._(jsObject, 1);
-}
-
-/**
- * Functions
- */
-
-class API_events {
-  /*
-   * API connection
-   */
-  Object _jsObject;
-
-  /*
-   * Events
-   */
-  Event_events_firstBasicEvent firstBasicEvent;
-  Event_events_secondBasicEvent secondBasicEvent;
-  Event_events_nonOptionalPrimitiveArgEvent nonOptionalPrimitiveArgEvent;
-  Event_events_optionalPrimitiveArgEvent optionalPrimitiveArgEvent;
-  Event_events_nonOptionalDictArgEvent nonOptionalDictArgEvent;
-  Event_events_optionalDictArgEvent optionalDictArgEvent;
-  API_events(this._jsObject) {
-    firstBasicEvent = new Event_events_firstBasicEvent(JS('', '#.firstBasicEvent', this._jsObject));
-    secondBasicEvent = new Event_events_secondBasicEvent(JS('', '#.secondBasicEvent', this._jsObject));
-    nonOptionalPrimitiveArgEvent = new Event_events_nonOptionalPrimitiveArgEvent(JS('', '#.nonOptionalPrimitiveArgEvent', this._jsObject));
-    optionalPrimitiveArgEvent = new Event_events_optionalPrimitiveArgEvent(JS('', '#.optionalPrimitiveArgEvent', this._jsObject));
-    nonOptionalDictArgEvent = new Event_events_nonOptionalDictArgEvent(JS('', '#.nonOptionalDictArgEvent', this._jsObject));
-    optionalDictArgEvent = new Event_events_optionalDictArgEvent(JS('', '#.optionalDictArgEvent', this._jsObject));
-  }
-}
diff --git a/tools/json_schema_compiler/dart_test/events.idl b/tools/json_schema_compiler/dart_test/events.idl
deleted file mode 100644
index f1fb4b6..0000000
--- a/tools/json_schema_compiler/dart_test/events.idl
+++ /dev/null
@@ -1,56 +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.
-
-// This comment is for the events namespace.
-namespace events {
-  dictionary EventArgumentElement {
-    DOMString elementStringArg;
-  };
-
-  dictionary EventArgument {
-    // A file entry
-    [instanceOf=FileEntry] object entryArg;
-
-    // A string
-    DOMString stringArg;
-
-    // A primitive
-    int intArg;
-
-    // An array
-    EventArgumentElement[] elements;
-
-    // Optional file entry
-    [instanceOf=FileEntry] object? optionalEntryArg;
-
-    // A string
-    DOMString? optionalStringArg;
-
-    // A primitive
-    int? optionalIntArg;
-
-    // An array
-    EventArgumentElement[]? optionalElements;
-  };
-
-  interface Events {
-    // Documentation for the first basic event.
-    static void firstBasicEvent();
-
-    // Documentation for the second basic event.
-    static void secondBasicEvent();
-
-    // Documentation for an event with a non-optional primitive argument.
-    static void nonOptionalPrimitiveArgEvent(int argument);
-
-    // Documentation for an event with an optional primitive argument.
-    static void optionalPrimitiveArgEvent(optional int argument);
-
-    // Documentation for an event with a non-optional dictionary argument.
-    static void nonOptionalDictArgEvent(EventArgument argument);
-
-    // Documentation for an event with a optional dictionary argument.
-    static void optionalDictArgEvent(EventArgument argument);
-  };
-};
diff --git a/tools/json_schema_compiler/dart_test/functions.dart b/tools/json_schema_compiler/dart_test/functions.dart
deleted file mode 100644
index cea71fd..0000000
--- a/tools/json_schema_compiler/dart_test/functions.dart
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-// Generated from namespace: functions
-
-part of chrome;
-
-/**
- * Types
- */
-
-class FunctionsDictType extends ChromeObject {
-  /*
-   * Private constructor
-   */
-  FunctionsDictType._proxy(_jsObject) : super._proxy(_jsObject);
-
-  /*
-   * Public accessors
-   */
-  /// A field.
-  int get a => JS('int', '#.a', this._jsObject);
-
-  void set a(int a) {
-    JS('void', '#.a = #', this._jsObject, a);
-  }
-
-
-  /*
-   * Methods
-   */
-  /// A parameter.
-  void voidFunc() => JS('void', '#.voidFunc()', this._jsObject);
-
-}
-
-/**
- * Functions
- */
-
-class API_functions {
-  /*
-   * API connection
-   */
-  Object _jsObject;
-
-  /*
-   * Functions
-   */
-  /// Simple function.
-  void voidFunc() => JS('void', '#.voidFunc()', this._jsObject);
-
-  /// Function taking a non-optional argument.
-  void argFunc(String s) => JS('void', '#.argFunc(#)', this._jsObject, s);
-
-  /// Function taking an optional argument.
-  void optionalArgFunc([String s]) => JS('void', '#.optionalArgFunc(#)', this._jsObject, s);
-
-  /// Function taking a non-optional dictionary argument.
-  void dictArgFunc(FunctionsDictType d) => JS('void', '#.dictArgFunc(#)', this._jsObject, convertArgument(d));
-
-  /// Function taking an optional dictionary argument.
-  void optionalDictArgFunc([FunctionsDictType d]) => JS('void', '#.optionalDictArgFunc(#)', this._jsObject, convertArgument(d));
-
-  /// Function taking an entry argument.
-  void entryArgFunc(Object entry) => JS('void', '#.entryArgFunc(#)', this._jsObject, convertArgument(entry));
-
-  /// Function taking a simple callback.
-  void callbackFunc(void c()) => JS('void', '#.callbackFunc(#)', this._jsObject, convertDartClosureToJS(c, 0));
-
-  /// Function taking an optional simple callback.
-  void optionalCallbackFunc([void c()]) => JS('void', '#.optionalCallbackFunc(#)', this._jsObject, convertDartClosureToJS(c, 0));
-
-  /// Function taking a primitive callback.
-  void primitiveCallbackFunc(void c(int i)) => JS('void', '#.primitiveCallbackFunc(#)', this._jsObject, convertDartClosureToJS(c, 1));
-
-  /// Function taking a dictionary callback.
-  void dictCallbackFunc(void c(DictType dict)) {
-    void __proxy_callback(dict) {
-      if (c != null) {
-        c(new DictType._proxy(dict));
-      }
-    }
-    JS('void', '#.dictCallbackFunc(#)', this._jsObject, convertDartClosureToJS(__proxy_callback, 1));
-  }
-
-  /// Function returning a dictionary.
-  FunctionsDictType dictRetFunc() => new FunctionsDictType._proxy(JS('', '#.dictRetFunc()', this._jsObject));
-
-  API_functions(this._jsObject) {
-  }
-}
diff --git a/tools/json_schema_compiler/dart_test/functions.idl b/tools/json_schema_compiler/dart_test/functions.idl
deleted file mode 100644
index e303d0d..0000000
--- a/tools/json_schema_compiler/dart_test/functions.idl
+++ /dev/null
@@ -1,55 +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.
-
-// A comment for the functions namespace.
-namespace functions {
-  callback SimpleCallback = void ();
-
-  callback PrimitiveCallback = void (int i);
-
-  callback DictCallback = void ([instanceOf=DictType] object dict);
-
-  dictionary DictType {
-    // A field.
-    int a;
-
-    // A parameter.
-    static void voidFunc();
-  };
-
-  interface Functions {
-    // Simple function.
-    static void voidFunc();
-
-    // Function taking a non-optional argument.
-    static void argFunc(DOMString s);
-
-    // Function taking an optional argument.
-    static void optionalArgFunc(optional DOMString s);
-
-    // Function taking a non-optional dictionary argument.
-    static void dictArgFunc(DictType d);
-
-    // Function taking an optional dictionary argument.
-    static void optionalDictArgFunc(optional DictType d);
-
-    // Function taking an entry argument.
-    static void entryArgFunc([intanceOf=FileEntry] object entry);
-
-    // Function taking a simple callback.
-    static void callbackFunc(SimpleCallback c);
-
-    // Function taking an optional simple callback.
-    static void optionalCallbackFunc(optional SimpleCallback c);
-
-    // Function taking a primitive callback.
-    static void primitiveCallbackFunc(PrimitiveCallback c);
-
-    // Function taking a dictionary callback.
-    static void dictCallbackFunc(DictCallback c);
-
-    // Function returning a dictionary.
-    static DictType dictRetFunc();
-  };
-};
diff --git a/tools/json_schema_compiler/dart_test/operatable_type.dart b/tools/json_schema_compiler/dart_test/operatable_type.dart
deleted file mode 100644
index 2cc9dc8..0000000
--- a/tools/json_schema_compiler/dart_test/operatable_type.dart
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-// Generated from namespace: operatable_type
-
-part of chrome;
-
-/**
- * Types
- */
-
-class Operatable_typeDictType extends ChromeObject {
-  /*
-   * Public constructor
-   */
-  Operatable_typeDictType({int x, int y}) {
-    if (x != null)
-      this.x = x;
-    if (y != null)
-      this.y = y;
-  }
-
-  /*
-   * Private constructor
-   */
-  Operatable_typeDictType._proxy(_jsObject) : super._proxy(_jsObject);
-
-  /*
-   * Public accessors
-   */
-  int get x => JS('int', '#.x', this._jsObject);
-
-  void set x(int x) {
-    JS('void', '#.x = #', this._jsObject, x);
-  }
-
-  int get y => JS('int', '#.y', this._jsObject);
-
-  void set y(int y) {
-    JS('void', '#.y = #', this._jsObject, y);
-  }
-
-}
-
-class Operatable_typeOperatableType extends ChromeObject {
-  /*
-   * Private constructor
-   */
-  Operatable_typeOperatableType._proxy(_jsObject) : super._proxy(_jsObject);
-
-  /*
-   * Public accessors
-   */
-  /// Documentation for the String t.
-  String get t => JS('String', '#.t', this._jsObject);
-
-  void set t(String t) {
-    JS('void', '#.t = #', this._jsObject, t);
-  }
-
-
-  /*
-   * Methods
-   */
-  /// Function returning nothing, taking nothing.
-  void voidFunc() => JS('void', '#.voidFunc()', this._jsObject);
-
-  /// Function returning primitive type.
-  int intRetFunc() => new int._proxy(JS('', '#.intRetFunc()', this._jsObject));
-
-  /// Function returning dictionary.
-  Operatable_typeDictType dictRetFunc() => new Operatable_typeDictType._proxy(JS('', '#.dictRetFunc()', this._jsObject));
-
-  /// Function taking primitive type.
-  void intArgFunc(int i) => JS('void', '#.intArgFunc(#)', this._jsObject, i);
-
-  /// Function taking dict type.
-  void dictArgFunc(Operatable_typeDictType d) => JS('void', '#.dictArgFunc(#)', this._jsObject, convertArgument(d));
-
-}
-
-/**
- * Functions
- */
-
-class API_operatable_type {
-  /*
-   * API connection
-   */
-  Object _jsObject;
-  API_operatable_type(this._jsObject) {
-  }
-}
diff --git a/tools/json_schema_compiler/dart_test/operatable_type.idl b/tools/json_schema_compiler/dart_test/operatable_type.idl
deleted file mode 100644
index 9c5f53c..0000000
--- a/tools/json_schema_compiler/dart_test/operatable_type.idl
+++ /dev/null
@@ -1,32 +0,0 @@
-// 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.
-
-// Top-level namespace-comment for operatableType
-namespace operatable_type {
-  dictionary DictType {
-    int x;
-    int y;
-  };
-
-  // Documentation for OperatableType.
-  dictionary OperatableType {
-    // Documentation for the String t.
-    DOMString t;
-
-    // Function returning nothing, taking nothing.
-    static void voidFunc();
-
-    // Function returning primitive type.
-    static int intRetFunc();
-
-    // Function returning dictionary.
-    static DictType dictRetFunc();
-
-    // Function taking primitive type.
-    static void intArgFunc(int i);
-
-    // Function taking dict type.
-    static void dictArgFunc(DictType d);
-  };
-};
diff --git a/tools/json_schema_compiler/dart_test/tags.dart b/tools/json_schema_compiler/dart_test/tags.dart
deleted file mode 100644
index e4adfd8..0000000
--- a/tools/json_schema_compiler/dart_test/tags.dart
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-// Generated from namespace: tags
-
-part of chrome;
-
-/**
- * Types
- */
-
-class TagsInlineDoc extends ChromeObject {
-  /*
-   * Public constructor
-   */
-  TagsInlineDoc({}) {
-  }
-
-  /*
-   * Private constructor
-   */
-  TagsInlineDoc._proxy(_jsObject) : super._proxy(_jsObject);
-}
-
-class TagsNodoc extends ChromeObject {
-  /*
-   * Public constructor
-   */
-  TagsNodoc({}) {
-  }
-
-  /*
-   * Private constructor
-   */
-  TagsNodoc._proxy(_jsObject) : super._proxy(_jsObject);
-}
-
-class TagsNocompile extends ChromeObject {
-  /*
-   * Public constructor
-   */
-  TagsNocompile({}) {
-  }
-
-  /*
-   * Private constructor
-   */
-  TagsNocompile._proxy(_jsObject) : super._proxy(_jsObject);
-}
-
-class TagsPlainDict extends ChromeObject {
-  /*
-   * Public constructor
-   */
-  TagsPlainDict({int inline_doc, String nodoc, double nocompile, fileEntry instance_of_tag}) {
-    if (inline_doc != null)
-      this.inline_doc = inline_doc;
-    if (nodoc != null)
-      this.nodoc = nodoc;
-    if (nocompile != null)
-      this.nocompile = nocompile;
-    if (instance_of_tag != null)
-      this.instance_of_tag = instance_of_tag;
-  }
-
-  /*
-   * Private constructor
-   */
-  TagsPlainDict._proxy(_jsObject) : super._proxy(_jsObject);
-
-  /*
-   * Public accessors
-   */
-  /// This int has the property [inline_doc].
-  int get inline_doc => JS('int', '#.inline_doc', this._jsObject);
-
-  void set inline_doc(int inline_doc) {
-    JS('void', '#.inline_doc = #', this._jsObject, inline_doc);
-  }
-
-  /// This String has the property [nodoc].
-  String get nodoc => JS('String', '#.nodoc', this._jsObject);
-
-  void set nodoc(String nodoc) {
-    JS('void', '#.nodoc = #', this._jsObject, nodoc);
-  }
-
-  /// This double has the property [nocompile].
-  double get nocompile => JS('double', '#.nocompile', this._jsObject);
-
-  void set nocompile(double nocompile) {
-    JS('void', '#.nocompile = #', this._jsObject, nocompile);
-  }
-
-  /// This object has the property [instanceOf=fileEntry].
-  fileEntry get instance_of_tag => JS('fileEntry', '#.instance_of_tag', this._jsObject);
-
-  void set instance_of_tag(fileEntry instance_of_tag) {
-    JS('void', '#.instance_of_tag = #', this._jsObject, convertArgument(instance_of_tag));
-  }
-
-}
-
-/**
- * Functions
- */
-
-class API_tags {
-  /*
-   * API connection
-   */
-  Object _jsObject;
-  API_tags(this._jsObject) {
-  }
-}
diff --git a/tools/json_schema_compiler/dart_test/tags.idl b/tools/json_schema_compiler/dart_test/tags.idl
deleted file mode 100644
index 7a029cd..0000000
--- a/tools/json_schema_compiler/dart_test/tags.idl
+++ /dev/null
@@ -1,33 +0,0 @@
-// 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.
-
-// A comment describing tags.
-namespace tags {
-  // This dictionary has the property [inline_doc].
-  [inline_doc] dictionary InlineDoc {
-  };
-
-  // This dictionary has the property [nodoc].
-  [nodoc] dictionary Nodoc {
-  };
-
-  // This dictionary has the property [nocompile].
-  [nocompile] dictionary Nocompile {
-  };
-
-  // This dictionary has no tags on the dictionary itself.
-  dictionary PlainDict {
-    // This int has the property [inline_doc].
-    [inline_doc] int inline_doc;
-
-    // This String has the property [nodoc].
-    [nodoc] String nodoc;
-
-    // This double has the property [nocompile].
-    [nocompile] double nocompile;
-
-    // This object has the property [instanceOf=fileEntry].
-    [instanceOf=fileEntry] object instance_of_tag;
-  };
-};
diff --git a/tools/json_schema_compiler/features_cc_generator.py b/tools/json_schema_compiler/features_cc_generator.py
deleted file mode 100644
index d3b3717..0000000
--- a/tools/json_schema_compiler/features_cc_generator.py
+++ /dev/null
@@ -1,95 +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.
-
-import os.path
-
-from code import Code
-import cpp_util
-
-
-class CCGenerator(object):
-  def Generate(self, feature_defs, source_file, namespace):
-    return _Generator(feature_defs, source_file, namespace).Generate()
-
-
-class _Generator(object):
-  """A .cc generator for features.
-  """
-  def __init__(self, feature_defs, source_file, namespace):
-    self._feature_defs = feature_defs
-    self._source_file = source_file
-    self._source_file_filename, _ = os.path.splitext(source_file)
-    self._class_name = cpp_util.ClassName(self._source_file_filename)
-    self._namespace = namespace
-
-  def Generate(self):
-    """Generates a Code object for features.
-    """
-    c = Code()
-    (c.Append(cpp_util.CHROMIUM_LICENSE)
-      .Append()
-      .Append(cpp_util.GENERATED_FEATURE_MESSAGE % self._source_file)
-      .Append()
-      .Append('#include <string>')
-      .Append()
-      .Append('#include "%s.h"' % self._source_file_filename)
-      .Append()
-      .Append('#include "base/logging.h"')
-      .Append()
-      .Concat(cpp_util.OpenNamespace(self._namespace))
-      .Append()
-    )
-
-    # Generate the constructor.
-    (c.Append('%s::%s() {' % (self._class_name, self._class_name))
-      .Sblock()
-    )
-    for feature in self._feature_defs:
-      c.Append('features_["%s"] = %s;'
-                       % (feature.name, cpp_util.ConstantName(feature.name)))
-    (c.Eblock()
-      .Append('}')
-      .Append()
-    )
-
-    # Generate the ToString function.
-    (c.Append('const char* %s::ToString('
-                  '%s::ID id) const {' % (self._class_name, self._class_name))
-      .Sblock()
-      .Append('switch (id) {')
-      .Sblock()
-    )
-    for feature in self._feature_defs:
-      c.Append('case %s: return "%s";' %
-          (cpp_util.ConstantName(feature.name), feature.name))
-    (c.Append('case kUnknown: break;')
-      .Append('case kEnumBoundary: break;')
-      .Eblock()
-      .Append('}')
-      .Append('NOTREACHED();')
-      .Append('return "";')
-    )
-    (c.Eblock()
-      .Append('}')
-      .Append()
-    )
-
-    # Generate the FromString function.
-
-    (c.Append('%s::ID %s::FromString('
-                  'const std::string& id) const {'
-                  % (self._class_name, self._class_name))
-      .Sblock()
-      .Append('std::map<std::string, %s::ID>::const_iterator it'
-                  ' = features_.find(id);' % self._class_name)
-      .Append('if (it == features_.end())')
-      .Append('  return kUnknown;')
-      .Append('return it->second;')
-      .Eblock()
-      .Append('}')
-      .Append()
-      .Cblock(cpp_util.CloseNamespace(self._namespace))
-    )
-
-    return c
diff --git a/tools/json_schema_compiler/features_compiler.py b/tools/json_schema_compiler/features_compiler.py
deleted file mode 100755
index 1e4e81a..0000000
--- a/tools/json_schema_compiler/features_compiler.py
+++ /dev/null
@@ -1,76 +0,0 @@
-#!/usr/bin/env python
-# 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.
-"""Generator for C++ features from json files.
-
-Usage example:
-  features_compiler.py --destdir gen --root /home/Work/src _permissions.json
-"""
-
-import optparse
-import os
-
-from schema_loader import SchemaLoader
-from features_cc_generator import CCGenerator
-from features_h_generator import HGenerator
-from model import CreateFeature
-
-
-def _GenerateSchema(filename, root, destdir, namespace):
-  """Generates C++ features files from the json file |filename|.
-  """
-  # Load in the feature permissions from the JSON file.
-  schema = os.path.normpath(filename)
-  schema_loader = SchemaLoader(os.path.dirname(os.path.relpath(schema, root)),
-    os.path.dirname(schema))
-  schema_filename = os.path.splitext(schema)[0]
-  feature_defs = schema_loader.LoadSchema(schema)
-
-  # Generate a list of the features defined and a list of their models.
-  feature_list = []
-  for feature_def, feature in feature_defs.iteritems():
-    feature_list.append(CreateFeature(feature_def, feature))
-
-  source_file_dir, _ = os.path.split(schema)
-  relpath = os.path.relpath(os.path.normpath(source_file_dir), root)
-  full_path = os.path.join(relpath, schema)
-
-  generators = [
-      ('%s.cc' % schema_filename, CCGenerator()),
-      ('%s.h' % schema_filename, HGenerator())
-  ]
-
-  # Generate and output the code for all features.
-  output_code = []
-  for filename, generator in generators:
-    code = generator.Generate(feature_list, full_path, namespace).Render()
-    if destdir:
-      with open(os.path.join(destdir, relpath, filename), 'w') as f:
-        f.write(code)
-    output_code += [filename, '', code, '']
-
-  return '\n'.join(output_code)
-
-
-if __name__ == '__main__':
-  parser = optparse.OptionParser(
-      description='Generates a C++ features model from JSON schema',
-      usage='usage: %prog [option]... schema')
-  parser.add_option('-r', '--root', default='.',
-      help='logical include root directory. Path to schema files from '
-           'specified dir will be the include path.')
-  parser.add_option('-d', '--destdir',
-      help='root directory to output generated files.')
-  parser.add_option('-n', '--namespace', default='generated_features',
-      help='C++ namespace for generated files. e.g extensions::api.')
-  (opts, filenames) = parser.parse_args()
-
-  # Only one file is currently specified.
-  if len(filenames) != 1:
-    raise ValueError('One (and only one) file is required (for now).')
-
-  result = _GenerateSchema(filenames[0], opts.root, opts.destdir,
-                           opts.namespace)
-  if not opts.destdir:
-    print result
diff --git a/tools/json_schema_compiler/features_h_generator.py b/tools/json_schema_compiler/features_h_generator.py
deleted file mode 100644
index 4198bb4..0000000
--- a/tools/json_schema_compiler/features_h_generator.py
+++ /dev/null
@@ -1,99 +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.
-
-import os.path
-
-from code import Code
-import cpp_util
-
-
-class HGenerator(object):
-  def Generate(self, features, source_file, namespace):
-    return _Generator(features, source_file, namespace).Generate()
-
-
-class _Generator(object):
-  """A .cc generator for features.
-  """
-  def __init__(self, features, source_file, namespace):
-    self._feature_defs = features
-    self._source_file = source_file
-    self._source_file_filename, _ = os.path.splitext(source_file)
-    self._class_name = cpp_util.ClassName(self._source_file_filename)
-    self._namespace = namespace
-
-  def Generate(self):
-    """Generates a Code object for features.
-    """
-    c = Code()
-    (c.Append(cpp_util.CHROMIUM_LICENSE)
-      .Append()
-      .Append(cpp_util.GENERATED_FEATURE_MESSAGE % self._source_file)
-      .Append()
-    )
-
-    # Hack: for the purpose of gyp the header file will always be the source
-    # file with its file extension replaced by '.h'. Assume so.
-    output_file = os.path.splitext(self._namespace.source_file)[0] + '.h'
-    ifndef_name = cpp_util.GenerateIfndefName(output_file)
-
-    (c.Append('#ifndef %s' % ifndef_name)
-      .Append('#define %s' % ifndef_name)
-      .Append()
-    )
-
-    (c.Append('#include <map>')
-      .Append('#include <string>')
-      .Append()
-      .Concat(cpp_util.OpenNamespace(self._namespace))
-      .Append()
-    )
-
-    (c.Append('class %s {' % self._class_name)
-      .Append(' public:')
-      .Sblock()
-      .Concat(self._GeneratePublicBody())
-      .Eblock()
-      .Append(' private:')
-      .Sblock()
-      .Concat(self._GeneratePrivateBody())
-      .Eblock('};')
-      .Append()
-      .Cblock(cpp_util.CloseNamespace(self._namespace))
-    )
-    (c.Append('#endif  // %s' % ifndef_name)
-      .Append()
-    )
-    return c
-
-  def _GeneratePublicBody(self):
-    c = Code()
-
-    (c.Append('%s();' % self._class_name)
-      .Append()
-      .Append('enum ID {')
-      .Concat(self._GenerateEnumConstants())
-      .Eblock('};')
-      .Append()
-      .Append('const char* ToString(ID id) const;')
-      .Append('ID FromString(const std::string& id) const;')
-      .Append()
-    )
-    return c
-
-  def _GeneratePrivateBody(self):
-    return Code().Append('std::map<std::string, '
-                         '%s::ID> features_;' % self._class_name)
-
-  def _GenerateEnumConstants(self):
-    c = Code()
-
-    (c.Sblock()
-      .Append('kUnknown,')
-    )
-    for feature in self._feature_defs:
-      c.Append('%s,' % cpp_util.ConstantName(feature.name))
-    c.Append('kEnumBoundary')
-
-    return c
diff --git a/tools/json_schema_compiler/h_generator.py b/tools/json_schema_compiler/h_generator.py
deleted file mode 100644
index a6d67db..0000000
--- a/tools/json_schema_compiler/h_generator.py
+++ /dev/null
@@ -1,397 +0,0 @@
-# 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.
-
-import os
-
-from code import Code
-from model import PropertyType
-import cpp_util
-import schema_util
-
-class HGenerator(object):
-  def __init__(self, type_generator):
-    self._type_generator = type_generator
-
-  def Generate(self, namespace):
-    return _Generator(namespace, self._type_generator).Generate()
-
-
-class _Generator(object):
-  """A .h generator for a namespace.
-  """
-  def __init__(self, namespace, cpp_type_generator):
-    self._namespace = namespace
-    self._type_helper = cpp_type_generator
-    self._generate_error_messages = namespace.compiler_options.get(
-        'generate_error_messages', False)
-
-  def Generate(self):
-    """Generates a Code object with the .h for a single namespace.
-    """
-    c = Code()
-    (c.Append(cpp_util.CHROMIUM_LICENSE)
-      .Append()
-      .Append(cpp_util.GENERATED_FILE_MESSAGE % self._namespace.source_file)
-      .Append()
-    )
-
-    # Hack: for the purpose of gyp the header file will always be the source
-    # file with its file extension replaced by '.h'. Assume so.
-    output_file = os.path.splitext(self._namespace.source_file)[0] + '.h'
-    ifndef_name = cpp_util.GenerateIfndefName(output_file)
-
-    (c.Append('#ifndef %s' % ifndef_name)
-      .Append('#define %s' % ifndef_name)
-      .Append()
-      .Append('#include <map>')
-      .Append('#include <string>')
-      .Append('#include <vector>')
-      .Append()
-      .Append('#include "base/basictypes.h"')
-      .Append('#include "base/logging.h"')
-      .Append('#include "base/memory/linked_ptr.h"')
-      .Append('#include "base/memory/scoped_ptr.h"')
-      .Append('#include "base/values.h"')
-      .Cblock(self._type_helper.GenerateIncludes())
-      .Append()
-    )
-
-    # TODO(calamity): These forward declarations should be #includes to allow
-    # $ref types from other files to be used as required params. This requires
-    # some detangling of windows and tabs which will currently lead to circular
-    # #includes.
-    c.Cblock(self._type_helper.GenerateForwardDeclarations())
-
-    cpp_namespace = cpp_util.GetCppNamespace(
-        self._namespace.environment.namespace_pattern,
-        self._namespace.unix_name)
-    c.Concat(cpp_util.OpenNamespace(cpp_namespace))
-    c.Append()
-    if self._namespace.properties:
-      (c.Append('//')
-        .Append('// Properties')
-        .Append('//')
-        .Append()
-      )
-      for property in self._namespace.properties.values():
-        property_code = self._type_helper.GeneratePropertyValues(
-            property,
-            'extern const %(type)s %(name)s;')
-        if property_code:
-          c.Cblock(property_code)
-    if self._namespace.types:
-      (c.Append('//')
-        .Append('// Types')
-        .Append('//')
-        .Append()
-        .Cblock(self._GenerateTypes(self._FieldDependencyOrder(),
-                                    is_toplevel=True,
-                                    generate_typedefs=True))
-      )
-    if self._namespace.functions:
-      (c.Append('//')
-        .Append('// Functions')
-        .Append('//')
-        .Append()
-      )
-      for function in self._namespace.functions.values():
-        c.Cblock(self._GenerateFunction(function))
-    if self._namespace.events:
-      (c.Append('//')
-        .Append('// Events')
-        .Append('//')
-        .Append()
-      )
-      for event in self._namespace.events.values():
-        c.Cblock(self._GenerateEvent(event))
-    (c.Concat(cpp_util.CloseNamespace(cpp_namespace))
-      .Append('#endif  // %s' % ifndef_name)
-      .Append()
-    )
-    return c
-
-  def _FieldDependencyOrder(self):
-    """Generates the list of types in the current namespace in an order in which
-    depended-upon types appear before types which depend on them.
-    """
-    dependency_order = []
-
-    def ExpandType(path, type_):
-      if type_ in path:
-        raise ValueError("Illegal circular dependency via cycle " +
-                         ", ".join(map(lambda x: x.name, path + [type_])))
-      for prop in type_.properties.values():
-        if (prop.type_ == PropertyType.REF and
-            schema_util.GetNamespace(prop.ref_type) == self._namespace.name):
-          ExpandType(path + [type_], self._namespace.types[prop.ref_type])
-      if not type_ in dependency_order:
-        dependency_order.append(type_)
-
-    for type_ in self._namespace.types.values():
-      ExpandType([], type_)
-    return dependency_order
-
-  def _GenerateEnumDeclaration(self, enum_name, type_):
-    """Generate a code object with the  declaration of a C++ enum.
-    """
-    c = Code()
-    c.Sblock('enum %s {' % enum_name)
-    c.Append(self._type_helper.GetEnumNoneValue(type_) + ',')
-    for value in type_.enum_values:
-      current_enum_string = self._type_helper.GetEnumValue(type_, value)
-      c.Append(current_enum_string + ',')
-    c.Append('%s = %s,' % (
-        self._type_helper.GetEnumLastValue(type_), current_enum_string))
-    c.Eblock('};')
-    return c
-
-  def _GenerateFields(self, props):
-    """Generates the field declarations when declaring a type.
-    """
-    c = Code()
-    needs_blank_line = False
-    for prop in props:
-      if needs_blank_line:
-        c.Append()
-      needs_blank_line = True
-      if prop.description:
-        c.Comment(prop.description)
-      # ANY is a base::Value which is abstract and cannot be a direct member, so
-      # we always need to wrap it in a scoped_ptr.
-      is_ptr = prop.optional or prop.type_.property_type == PropertyType.ANY
-      (c.Append('%s %s;' % (
-           self._type_helper.GetCppType(prop.type_, is_ptr=is_ptr),
-           prop.unix_name))
-      )
-    return c
-
-  def _GenerateType(self, type_, is_toplevel=False, generate_typedefs=False):
-    """Generates a struct for |type_|.
-
-    |is_toplevel|       implies that the type was declared in the "types" field
-                        of an API schema. This determines the correct function
-                        modifier(s).
-    |generate_typedefs| controls whether primitive types should be generated as
-                        a typedef. This may not always be desired. If false,
-                        primitive types are ignored.
-    """
-    classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
-    c = Code()
-
-    if type_.functions:
-      # Wrap functions within types in the type's namespace.
-      (c.Append('namespace %s {' % classname)
-        .Append()
-      )
-      for function in type_.functions.values():
-        c.Cblock(self._GenerateFunction(function))
-      c.Append('}  // namespace %s' % classname)
-    elif type_.property_type == PropertyType.ARRAY:
-      if generate_typedefs and type_.description:
-        c.Comment(type_.description)
-      c.Cblock(self._GenerateType(type_.item_type))
-      if generate_typedefs:
-        (c.Append('typedef std::vector<%s > %s;' % (
-                       self._type_helper.GetCppType(type_.item_type),
-                       classname))
-        )
-    elif type_.property_type == PropertyType.STRING:
-      if generate_typedefs:
-        if type_.description:
-          c.Comment(type_.description)
-        c.Append('typedef std::string %(classname)s;')
-    elif type_.property_type == PropertyType.ENUM:
-      if type_.description:
-        c.Comment(type_.description)
-      c.Cblock(self._GenerateEnumDeclaration(classname, type_));
-      # Top level enums are in a namespace scope so the methods shouldn't be
-      # static. On the other hand, those declared inline (e.g. in an object) do.
-      maybe_static = '' if is_toplevel else 'static '
-      (c.Append()
-        .Append('%sstd::string ToString(%s as_enum);' %
-                (maybe_static, classname))
-        .Append('%s%s Parse%s(const std::string& as_string);' %
-                (maybe_static, classname, classname))
-      )
-    elif type_.property_type in (PropertyType.CHOICES,
-                                 PropertyType.OBJECT):
-      if type_.description:
-        c.Comment(type_.description)
-      (c.Sblock('struct %(classname)s {')
-          .Append('%(classname)s();')
-          .Append('~%(classname)s();')
-      )
-      if type_.origin.from_json:
-        (c.Append()
-          .Comment('Populates a %s object from a base::Value. Returns'
-                   ' whether |out| was successfully populated.' % classname)
-          .Append('static bool Populate(%s);' % self._GenerateParams(
-              ('const base::Value& value', '%s* out' % classname)))
-        )
-        if is_toplevel:
-          (c.Append()
-            .Comment('Creates a %s object from a base::Value, or NULL on '
-                     'failure.' % classname)
-            .Append('static scoped_ptr<%s> FromValue(%s);' % (
-                classname, self._GenerateParams(('const base::Value& value',))))
-          )
-      if type_.origin.from_client:
-        value_type = ('base::Value'
-                      if type_.property_type is PropertyType.CHOICES else
-                      'base::DictionaryValue')
-        (c.Append()
-          .Comment('Returns a new %s representing the serialized form of this '
-                   '%s object.' % (value_type, classname))
-          .Append('scoped_ptr<%s> ToValue() const;' % value_type)
-        )
-      if type_.property_type == PropertyType.CHOICES:
-        # Choices are modelled with optional fields for each choice. Exactly one
-        # field of the choice is guaranteed to be set by the compiler.
-        c.Cblock(self._GenerateTypes(type_.choices))
-        c.Append('// Choices:')
-        for choice_type in type_.choices:
-          c.Append('%s as_%s;' % (
-              self._type_helper.GetCppType(choice_type, is_ptr=True),
-              choice_type.unix_name))
-      else:
-        properties = type_.properties.values()
-        (c.Append()
-          .Cblock(self._GenerateTypes(p.type_ for p in properties))
-          .Cblock(self._GenerateFields(properties)))
-        if type_.additional_properties is not None:
-          # Most additionalProperties actually have type "any", which is better
-          # modelled as a DictionaryValue rather than a map of string -> Value.
-          if type_.additional_properties.property_type == PropertyType.ANY:
-            c.Append('base::DictionaryValue additional_properties;')
-          else:
-            (c.Cblock(self._GenerateType(type_.additional_properties))
-              .Append('std::map<std::string, %s> additional_properties;' %
-                  cpp_util.PadForGenerics(
-                      self._type_helper.GetCppType(type_.additional_properties,
-                                                   is_in_container=True)))
-            )
-      (c.Eblock()
-        .Append()
-        .Sblock(' private:')
-          .Append('DISALLOW_COPY_AND_ASSIGN(%(classname)s);')
-        .Eblock('};')
-      )
-    return c.Substitute({'classname': classname})
-
-  def _GenerateEvent(self, event):
-    """Generates the namespaces for an event.
-    """
-    c = Code()
-    # TODO(kalman): use event.unix_name not Classname.
-    event_namespace = cpp_util.Classname(event.name)
-    (c.Append('namespace %s {' % event_namespace)
-      .Append()
-      .Concat(self._GenerateEventNameConstant(event))
-      .Concat(self._GenerateCreateCallbackArguments(event))
-      .Eblock('}  // namespace %s' % event_namespace)
-    )
-    return c
-
-  def _GenerateFunction(self, function):
-    """Generates the namespaces and structs for a function.
-    """
-    c = Code()
-    # TODO(kalman): Use function.unix_name not Classname here.
-    function_namespace = cpp_util.Classname(function.name)
-    # Windows has a #define for SendMessage, so to avoid any issues, we need
-    # to not use the name.
-    if function_namespace == 'SendMessage':
-      function_namespace = 'PassMessage'
-    (c.Append('namespace %s {' % function_namespace)
-      .Append()
-      .Cblock(self._GenerateFunctionParams(function))
-    )
-    if function.callback:
-      c.Cblock(self._GenerateFunctionResults(function.callback))
-    c.Append('}  // namespace %s' % function_namespace)
-    return c
-
-  def _GenerateFunctionParams(self, function):
-    """Generates the struct for passing parameters from JSON to a function.
-    """
-    if not function.params:
-      return Code()
-
-    c = Code()
-    (c.Sblock('struct Params {')
-      .Append('static scoped_ptr<Params> Create(%s);' % self._GenerateParams(
-          ('const base::ListValue& args',)))
-      .Append('~Params();')
-      .Append()
-      .Cblock(self._GenerateTypes(p.type_ for p in function.params))
-      .Cblock(self._GenerateFields(function.params))
-      .Eblock()
-      .Append()
-      .Sblock(' private:')
-        .Append('Params();')
-        .Append()
-        .Append('DISALLOW_COPY_AND_ASSIGN(Params);')
-      .Eblock('};')
-    )
-    return c
-
-  def _GenerateTypes(self, types, is_toplevel=False, generate_typedefs=False):
-    """Generate the structures required by a property such as OBJECT classes
-    and enums.
-    """
-    c = Code()
-    for type_ in types:
-      c.Cblock(self._GenerateType(type_,
-                                  is_toplevel=is_toplevel,
-                                  generate_typedefs=generate_typedefs))
-    return c
-
-  def _GenerateCreateCallbackArguments(self, function):
-    """Generates functions for passing parameters to a callback.
-    """
-    c = Code()
-    params = function.params
-    c.Cblock(self._GenerateTypes((p.type_ for p in params), is_toplevel=True))
-
-    declaration_list = []
-    for param in params:
-      if param.description:
-        c.Comment(param.description)
-      declaration_list.append(cpp_util.GetParameterDeclaration(
-          param, self._type_helper.GetCppType(param.type_)))
-    c.Append('scoped_ptr<base::ListValue> Create(%s);' %
-             ', '.join(declaration_list))
-    return c
-
-  def _GenerateEventNameConstant(self, event):
-    """Generates a constant string array for the event name.
-    """
-    c = Code()
-    c.Append('extern const char kEventName[];  // "%s.%s"' % (
-                 self._namespace.name, event.name))
-    c.Append()
-    return c
-
-  def _GenerateFunctionResults(self, callback):
-    """Generates namespace for passing a function's result back.
-    """
-    c = Code()
-    (c.Append('namespace Results {')
-      .Append()
-      .Concat(self._GenerateCreateCallbackArguments(callback))
-      .Append('}  // namespace Results')
-    )
-    return c
-
-  def _GenerateParams(self, params):
-    """Builds the parameter list for a function, given an array of parameters.
-    """
-    # |error| is populated with warnings and/or errors found during parsing.
-    # |error| being set does not necessarily imply failure and may be
-    # recoverable.
-    # For example, optional properties may have failed to parse, but the
-    # parser was able to continue.
-    if self._generate_error_messages:
-      params += ('base::string16* error',)
-    return ', '.join(str(p) for p in params)
diff --git a/tools/json_schema_compiler/highlighters/__init__.py b/tools/json_schema_compiler/highlighters/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/tools/json_schema_compiler/highlighters/__init__.py
+++ /dev/null
diff --git a/tools/json_schema_compiler/highlighters/hilite_me_highlighter.py b/tools/json_schema_compiler/highlighters/hilite_me_highlighter.py
deleted file mode 100644
index af04847..0000000
--- a/tools/json_schema_compiler/highlighters/hilite_me_highlighter.py
+++ /dev/null
@@ -1,30 +0,0 @@
-# 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.
-
-import urllib
-import urllib2
-
-class HiliteMeHighlighter(object):
-  """Highlighter that calls the http://hilite.me API to highlight code.
-  """
-  def GetCSS(self, style):
-    return ''
-
-  def GetCodeElement(self, code, style):
-    # Call hilite.me API to do syntax highlighting
-    return urllib2.urlopen('http://hilite.me/api',
-        urllib.urlencode([
-            ('code', code),
-            ('lexer', 'cpp'),
-            ('style', style),
-            ('linenos', 1)])
-    ).read()
-
-  def DisplayName(self):
-    return 'hilite.me (slow, requires internet)'
-
-  def GetStyles(self):
-    return ['monokai', 'manni', 'perldoc', 'borland', 'colorful', 'default',
-        'murphy', 'vs', 'trac', 'tango', 'fruity', 'autumn', 'bw', 'emacs',
-        'vim', 'pastie', 'friendly', 'native']
diff --git a/tools/json_schema_compiler/highlighters/none_highlighter.py b/tools/json_schema_compiler/highlighters/none_highlighter.py
deleted file mode 100644
index ac1cc2b..0000000
--- a/tools/json_schema_compiler/highlighters/none_highlighter.py
+++ /dev/null
@@ -1,20 +0,0 @@
-# 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.
-
-import cgi
-
-class NoneHighlighter(object):
-  """Highlighter that just wraps code in a <pre>.
-  """
-  def GetCSS(self, style):
-    return ''
-
-  def GetCodeElement(self, code, style):
-    return '<pre>' + cgi.escape(code) + '</pre>'
-
-  def DisplayName(self):
-    return 'none'
-
-  def GetStyles(self):
-    return []
diff --git a/tools/json_schema_compiler/highlighters/pygments_highlighter.py b/tools/json_schema_compiler/highlighters/pygments_highlighter.py
deleted file mode 100644
index 06abd33..0000000
--- a/tools/json_schema_compiler/highlighters/pygments_highlighter.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# 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.
-
-import sys
-try:
-  import pygments
-  from pygments.lexers import CppLexer
-  from pygments.formatters import HtmlFormatter
-  PYGMENTS_IMPORTED = True
-except ImportError:
-  print('It appears that Pygments is not installed. '
-    'Can be installed using easy_install Pygments or from http://pygments.org.')
-  PYGMENTS_IMPORTED = False
-
-class PygmentsHighlighter(object):
-  def __init__(self):
-    if not PYGMENTS_IMPORTED:
-      raise ImportError('Pygments not installed')
-
-  """Highlighter that uses the python pygments library to highlight code.
-  """
-  def GetCSS(self, style):
-    formatter = HtmlFormatter(linenos=True,
-        style=pygments.styles.get_style_by_name(style))
-    return formatter.get_style_defs('.highlight')
-
-  def GetCodeElement(self, code, style):
-    formatter = HtmlFormatter(linenos=True,
-            style=pygments.styles.get_style_by_name(style))
-    return pygments.highlight(code, CppLexer(), formatter)
-
-  def DisplayName(self):
-    return 'pygments' + ('' if PYGMENTS_IMPORTED else ' (not installed)')
-
-  def GetStyles(self):
-    return list(pygments.styles.get_all_styles())
diff --git a/tools/json_schema_compiler/idl_schema.py b/tools/json_schema_compiler/idl_schema.py
deleted file mode 100755
index a913756..0000000
--- a/tools/json_schema_compiler/idl_schema.py
+++ /dev/null
@@ -1,488 +0,0 @@
-#! /usr/bin/env python
-# 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.
-
-import itertools
-import json
-import os.path
-import re
-import sys
-
-from json_parse import OrderedDict
-
-# This file is a peer to json_schema.py. Each of these files understands a
-# certain format describing APIs (either JSON or IDL), reads files written
-# in that format into memory, and emits them as a Python array of objects
-# corresponding to those APIs, where the objects are formatted in a way that
-# the JSON schema compiler understands. compiler.py drives both idl_schema.py
-# and json_schema.py.
-
-# idl_parser expects to be able to import certain files in its directory,
-# so let's set things up the way it wants.
-_idl_generators_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
-                                    os.pardir, os.pardir, 'ppapi', 'generators')
-if _idl_generators_path in sys.path:
-  import idl_parser
-else:
-  sys.path.insert(0, _idl_generators_path)
-  try:
-    import idl_parser
-  finally:
-    sys.path.pop(0)
-
-def ProcessComment(comment):
-  '''
-  Convert a comment into a parent comment and a list of parameter comments.
-
-  Function comments are of the form:
-    Function documentation. May contain HTML and multiple lines.
-
-    |arg1_name|: Description of arg1. Use <var>argument</var> to refer
-    to other arguments.
-    |arg2_name|: Description of arg2...
-
-  Newlines are removed, and leading and trailing whitespace is stripped.
-
-  Args:
-    comment: The string from a Comment node.
-
-  Returns: A tuple that looks like:
-    (
-      "The processed comment, minus all |parameter| mentions.",
-      {
-        'parameter_name_1': "The comment that followed |parameter_name_1|:",
-        ...
-      }
-    )
-  '''
-  def add_paragraphs(content):
-    paragraphs = content.split('\n\n')
-    if len(paragraphs) < 2:
-      return content
-    return '<p>' + '</p><p>'.join(p.strip() for p in paragraphs) + '</p>'
-
-  # Find all the parameter comments of the form '|name|: comment'.
-  parameter_starts = list(re.finditer(r' *\|([^|]*)\| *: *', comment))
-
-  # Get the parent comment (everything before the first parameter comment.
-  first_parameter_location = (parameter_starts[0].start()
-                              if parameter_starts else len(comment))
-  parent_comment = (add_paragraphs(comment[:first_parameter_location].strip())
-                    .replace('\n', ''))
-
-  params = OrderedDict()
-  for (cur_param, next_param) in itertools.izip_longest(parameter_starts,
-                                                        parameter_starts[1:]):
-    param_name = cur_param.group(1)
-
-    # A parameter's comment goes from the end of its introduction to the
-    # beginning of the next parameter's introduction.
-    param_comment_start = cur_param.end()
-    param_comment_end = next_param.start() if next_param else len(comment)
-    params[param_name] = (
-        add_paragraphs(comment[param_comment_start:param_comment_end].strip())
-        .replace('\n', ''))
-
-  return (parent_comment, params)
-
-
-class Callspec(object):
-  '''
-  Given a Callspec node representing an IDL function declaration, converts into
-  a tuple:
-      (name, list of function parameters, return type)
-  '''
-  def __init__(self, callspec_node, comment):
-    self.node = callspec_node
-    self.comment = comment
-
-  def process(self, callbacks):
-    parameters = []
-    return_type = None
-    if self.node.GetProperty('TYPEREF') not in ('void', None):
-      return_type = Typeref(self.node.GetProperty('TYPEREF'),
-                            self.node.parent,
-                            {'name': self.node.GetName()}).process(callbacks)
-      # The IDL parser doesn't allow specifying return types as optional.
-      # Instead we infer any object return values to be optional.
-      # TODO(asargent): fix the IDL parser to support optional return types.
-      if return_type.get('type') == 'object' or '$ref' in return_type:
-        return_type['optional'] = True
-    for node in self.node.GetChildren():
-      parameter = Param(node).process(callbacks)
-      if parameter['name'] in self.comment:
-        parameter['description'] = self.comment[parameter['name']]
-      parameters.append(parameter)
-    return (self.node.GetName(), parameters, return_type)
-
-
-class Param(object):
-  '''
-  Given a Param node representing a function parameter, converts into a Python
-  dictionary that the JSON schema compiler expects to see.
-  '''
-  def __init__(self, param_node):
-    self.node = param_node
-
-  def process(self, callbacks):
-    return Typeref(self.node.GetProperty('TYPEREF'),
-                   self.node,
-                   {'name': self.node.GetName()}).process(callbacks)
-
-
-class Dictionary(object):
-  '''
-  Given an IDL Dictionary node, converts into a Python dictionary that the JSON
-  schema compiler expects to see.
-  '''
-  def __init__(self, dictionary_node):
-    self.node = dictionary_node
-
-  def process(self, callbacks):
-    properties = OrderedDict()
-    for node in self.node.GetChildren():
-      if node.cls == 'Member':
-        k, v = Member(node).process(callbacks)
-        properties[k] = v
-    result = {'id': self.node.GetName(),
-              'properties': properties,
-              'type': 'object'}
-    if self.node.GetProperty('nodoc'):
-      result['nodoc'] = True
-    elif self.node.GetProperty('inline_doc'):
-      result['inline_doc'] = True
-    elif self.node.GetProperty('noinline_doc'):
-      result['noinline_doc'] = True
-    return result
-
-
-
-class Member(object):
-  '''
-  Given an IDL dictionary or interface member, converts into a name/value pair
-  where the value is a Python dictionary that the JSON schema compiler expects
-  to see.
-  '''
-  def __init__(self, member_node):
-    self.node = member_node
-
-  def process(self, callbacks):
-    properties = OrderedDict()
-    name = self.node.GetName()
-    if self.node.GetProperty('deprecated'):
-      properties['deprecated'] = self.node.GetProperty('deprecated')
-    if self.node.GetProperty('allowAmbiguousOptionalArguments'):
-      properties['allowAmbiguousOptionalArguments'] = True
-    for property_name in ('OPTIONAL', 'nodoc', 'nocompile', 'nodart'):
-      if self.node.GetProperty(property_name):
-        properties[property_name.lower()] = True
-    for option_name, sanitizer in [
-        ('maxListeners', int),
-        ('supportsFilters', lambda s: s == 'true'),
-        ('supportsListeners', lambda s: s == 'true'),
-        ('supportsRules', lambda s: s == 'true')]:
-      if self.node.GetProperty(option_name):
-        if 'options' not in properties:
-          properties['options'] = {}
-        properties['options'][option_name] = sanitizer(self.node.GetProperty(
-          option_name))
-    is_function = False
-    parameter_comments = OrderedDict()
-    for node in self.node.GetChildren():
-      if node.cls == 'Comment':
-        (parent_comment, parameter_comments) = ProcessComment(node.GetName())
-        properties['description'] = parent_comment
-      elif node.cls == 'Callspec':
-        is_function = True
-        name, parameters, return_type = (Callspec(node, parameter_comments)
-                                         .process(callbacks))
-        properties['parameters'] = parameters
-        if return_type is not None:
-          properties['returns'] = return_type
-    properties['name'] = name
-    if is_function:
-      properties['type'] = 'function'
-    else:
-      properties = Typeref(self.node.GetProperty('TYPEREF'),
-                           self.node, properties).process(callbacks)
-    enum_values = self.node.GetProperty('legalValues')
-    if enum_values:
-      if properties['type'] == 'integer':
-        enum_values = map(int, enum_values)
-      elif properties['type'] == 'double':
-        enum_values = map(float, enum_values)
-      properties['enum'] = enum_values
-    return name, properties
-
-
-class Typeref(object):
-  '''
-  Given a TYPEREF property representing the type of dictionary member or
-  function parameter, converts into a Python dictionary that the JSON schema
-  compiler expects to see.
-  '''
-  def __init__(self, typeref, parent, additional_properties):
-    self.typeref = typeref
-    self.parent = parent
-    self.additional_properties = additional_properties
-
-  def process(self, callbacks):
-    properties = self.additional_properties
-    result = properties
-
-    if self.parent.GetPropertyLocal('OPTIONAL'):
-      properties['optional'] = True
-
-    # The IDL parser denotes array types by adding a child 'Array' node onto
-    # the Param node in the Callspec.
-    for sibling in self.parent.GetChildren():
-      if sibling.cls == 'Array' and sibling.GetName() == self.parent.GetName():
-        properties['type'] = 'array'
-        properties['items'] = OrderedDict()
-        properties = properties['items']
-        break
-
-    if self.typeref == 'DOMString':
-      properties['type'] = 'string'
-    elif self.typeref == 'boolean':
-      properties['type'] = 'boolean'
-    elif self.typeref == 'double':
-      properties['type'] = 'number'
-    elif self.typeref == 'long':
-      properties['type'] = 'integer'
-    elif self.typeref == 'any':
-      properties['type'] = 'any'
-    elif self.typeref == 'object':
-      properties['type'] = 'object'
-      if 'additionalProperties' not in properties:
-        properties['additionalProperties'] = OrderedDict()
-      properties['additionalProperties']['type'] = 'any'
-      instance_of = self.parent.GetProperty('instanceOf')
-      if instance_of:
-        properties['isInstanceOf'] = instance_of
-    elif self.typeref == 'ArrayBuffer':
-      properties['type'] = 'binary'
-      properties['isInstanceOf'] = 'ArrayBuffer'
-    elif self.typeref == 'FileEntry':
-      properties['type'] = 'object'
-      properties['isInstanceOf'] = 'FileEntry'
-      if 'additionalProperties' not in properties:
-        properties['additionalProperties'] = OrderedDict()
-      properties['additionalProperties']['type'] = 'any'
-    elif self.parent.GetPropertyLocal('Union'):
-      choices = []
-      properties['choices'] = [Typeref(node.GetProperty('TYPEREF'),
-                                       node,
-                                       OrderedDict()).process(callbacks)
-                               for node in self.parent.GetChildren()
-                               if node.cls == 'Option']
-    elif self.typeref is None:
-      properties['type'] = 'function'
-    else:
-      if self.typeref in callbacks:
-        # Do not override name and description if they are already specified.
-        name = properties.get('name', None)
-        description = properties.get('description', None)
-        properties.update(callbacks[self.typeref])
-        if description is not None:
-          properties['description'] = description
-        if name is not None:
-          properties['name'] = name
-      else:
-        properties['$ref'] = self.typeref
-    return result
-
-
-class Enum(object):
-  '''
-  Given an IDL Enum node, converts into a Python dictionary that the JSON
-  schema compiler expects to see.
-  '''
-  def __init__(self, enum_node):
-    self.node = enum_node
-    self.description = ''
-
-  def process(self, callbacks):
-    enum = []
-    for node in self.node.GetChildren():
-      if node.cls == 'EnumItem':
-        enum_value = {'name': node.GetName()}
-        for child in node.GetChildren():
-          if child.cls == 'Comment':
-            enum_value['description'] = ProcessComment(child.GetName())[0]
-          else:
-            raise ValueError('Did not process %s %s' % (child.cls, child))
-        enum.append(enum_value)
-      elif node.cls == 'Comment':
-        self.description = ProcessComment(node.GetName())[0]
-      else:
-        sys.exit('Did not process %s %s' % (node.cls, node))
-    result = {'id' : self.node.GetName(),
-              'description': self.description,
-              'type': 'string',
-              'enum': enum}
-    for property_name in (
-        'inline_doc', 'noinline_doc', 'nodoc', 'cpp_enum_prefix_override',):
-      if self.node.GetProperty(property_name):
-        result[property_name] = self.node.GetProperty(property_name)
-    if self.node.GetProperty('deprecated'):
-        result[deprecated] = self.node.GetProperty('deprecated')
-    return result
-
-
-class Namespace(object):
-  '''
-  Given an IDLNode representing an IDL namespace, converts into a Python
-  dictionary that the JSON schema compiler expects to see.
-  '''
-
-  def __init__(self,
-               namespace_node,
-               description,
-               nodoc=False,
-               internal=False,
-               platforms=None,
-               compiler_options=None,
-               deprecated=None):
-    self.namespace = namespace_node
-    self.nodoc = nodoc
-    self.internal = internal
-    self.platforms = platforms
-    self.compiler_options = compiler_options
-    self.events = []
-    self.functions = []
-    self.types = []
-    self.callbacks = OrderedDict()
-    self.description = description
-    self.deprecated = deprecated
-
-  def process(self):
-    for node in self.namespace.GetChildren():
-      if node.cls == 'Dictionary':
-        self.types.append(Dictionary(node).process(self.callbacks))
-      elif node.cls == 'Callback':
-        k, v = Member(node).process(self.callbacks)
-        self.callbacks[k] = v
-      elif node.cls == 'Interface' and node.GetName() == 'Functions':
-        self.functions = self.process_interface(node)
-      elif node.cls == 'Interface' and node.GetName() == 'Events':
-        self.events = self.process_interface(node)
-      elif node.cls == 'Enum':
-        self.types.append(Enum(node).process(self.callbacks))
-      else:
-        sys.exit('Did not process %s %s' % (node.cls, node))
-    if self.compiler_options is not None:
-      compiler_options = self.compiler_options
-    else:
-      compiler_options = {}
-    return {'namespace': self.namespace.GetName(),
-            'description': self.description,
-            'nodoc': self.nodoc,
-            'types': self.types,
-            'functions': self.functions,
-            'internal': self.internal,
-            'events': self.events,
-            'platforms': self.platforms,
-            'compiler_options': compiler_options,
-            'deprecated': self.deprecated}
-
-  def process_interface(self, node):
-    members = []
-    for member in node.GetChildren():
-      if member.cls == 'Member':
-        name, properties = Member(member).process(self.callbacks)
-        members.append(properties)
-    return members
-
-
-class IDLSchema(object):
-  '''
-  Given a list of IDLNodes and IDLAttributes, converts into a Python list
-  of api_defs that the JSON schema compiler expects to see.
-  '''
-
-  def __init__(self, idl):
-    self.idl = idl
-
-  def process(self):
-    namespaces = []
-    nodoc = False
-    internal = False
-    description = None
-    platforms = None
-    compiler_options = {}
-    deprecated = None
-    for node in self.idl:
-      if node.cls == 'Namespace':
-        if not description:
-          # TODO(kalman): Go back to throwing an error here.
-          print('%s must have a namespace-level comment. This will '
-                           'appear on the API summary page.' % node.GetName())
-          description = ''
-        namespace = Namespace(node, description, nodoc, internal,
-                              platforms=platforms,
-                              compiler_options=compiler_options or None,
-                              deprecated=deprecated)
-        namespaces.append(namespace.process())
-        nodoc = False
-        internal = False
-        platforms = None
-        compiler_options = None
-      elif node.cls == 'Copyright':
-        continue
-      elif node.cls == 'Comment':
-        description = node.GetName()
-      elif node.cls == 'ExtAttribute':
-        if node.name == 'nodoc':
-          nodoc = bool(node.value)
-        elif node.name == 'internal':
-          internal = bool(node.value)
-        elif node.name == 'platforms':
-          platforms = list(node.value)
-        elif node.name == 'implemented_in':
-          compiler_options['implemented_in'] = node.value
-        elif node.name == 'camel_case_enum_to_string':
-          compiler_options['camel_case_enum_to_string'] = node.value
-        elif node.name == 'deprecated':
-          deprecated = str(node.value)
-        else:
-          continue
-      else:
-        sys.exit('Did not process %s %s' % (node.cls, node))
-    return namespaces
-
-
-def Load(filename):
-  '''
-  Given the filename of an IDL file, parses it and returns an equivalent
-  Python dictionary in a format that the JSON schema compiler expects to see.
-  '''
-
-  f = open(filename, 'r')
-  contents = f.read()
-  f.close()
-
-  idl = idl_parser.IDLParser().ParseData(contents, filename)
-  idl_schema = IDLSchema(idl)
-  return idl_schema.process()
-
-
-def Main():
-  '''
-  Dump a json serialization of parse result for the IDL files whose names
-  were passed in on the command line.
-  '''
-  if len(sys.argv) > 1:
-    for filename in sys.argv[1:]:
-      schema = Load(filename)
-      print json.dumps(schema, indent=2)
-  else:
-    contents = sys.stdin.read()
-    idl = idl_parser.IDLParser().ParseData(contents, '<stdin>')
-    schema = IDLSchema(idl).process()
-    print json.dumps(schema, indent=2)
-
-
-if __name__ == '__main__':
-  Main()
diff --git a/tools/json_schema_compiler/idl_schema_test.py b/tools/json_schema_compiler/idl_schema_test.py
deleted file mode 100755
index a045716..0000000
--- a/tools/json_schema_compiler/idl_schema_test.py
+++ /dev/null
@@ -1,396 +0,0 @@
-#!/usr/bin/env python
-# 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.
-
-import idl_schema
-import unittest
-
-from json_parse import OrderedDict
-
-def getFunction(schema, name):
-  for item in schema['functions']:
-    if item['name'] == name:
-      return item
-  raise KeyError('Missing function %s' % name)
-
-
-def getParams(schema, name):
-  function = getFunction(schema, name)
-  return function['parameters']
-
-
-def getReturns(schema, name):
-  function = getFunction(schema, name)
-  return function['returns']
-
-
-def getType(schema, id):
-  for item in schema['types']:
-    if item['id'] == id:
-      return item
-
-
-class IdlSchemaTest(unittest.TestCase):
-  def setUp(self):
-    loaded = idl_schema.Load('test/idl_basics.idl')
-    self.assertEquals(1, len(loaded))
-    self.assertEquals('idl_basics', loaded[0]['namespace'])
-    self.idl_basics = loaded[0]
-    self.maxDiff = None
-
-  def testSimpleCallbacks(self):
-    schema = self.idl_basics
-    expected = [{'type': 'function', 'name': 'cb', 'parameters':[]}]
-    self.assertEquals(expected, getParams(schema, 'function4'))
-
-    expected = [{'type': 'function', 'name': 'cb',
-                 'parameters':[{'name': 'x', 'type': 'integer'}]}]
-    self.assertEquals(expected, getParams(schema, 'function5'))
-
-    expected = [{'type': 'function', 'name': 'cb',
-                 'parameters':[{'name': 'arg', '$ref': 'MyType1'}]}]
-    self.assertEquals(expected, getParams(schema, 'function6'))
-
-  def testCallbackWithArrayArgument(self):
-    schema = self.idl_basics
-    expected = [{'type': 'function', 'name': 'cb',
-                 'parameters':[{'name': 'arg', 'type': 'array',
-                                'items':{'$ref': 'MyType2'}}]}]
-    self.assertEquals(expected, getParams(schema, 'function12'))
-
-
-  def testArrayOfCallbacks(self):
-    schema = idl_schema.Load('test/idl_function_types.idl')[0]
-    expected = [{'type': 'array', 'name': 'callbacks',
-                 'items':{'type': 'function', 'name': 'MyCallback',
-                          'parameters':[{'type': 'integer', 'name': 'x'}]}}]
-    self.assertEquals(expected, getParams(schema, 'whatever'))
-
-  def testLegalValues(self):
-    self.assertEquals({
-        'x': {'name': 'x', 'type': 'integer', 'enum': [1,2],
-              'description': 'This comment tests "double-quotes".'},
-        'y': {'name': 'y', 'type': 'string'},
-        'z': {'name': 'z', 'type': 'string'},
-        'a': {'name': 'a', 'type': 'string'},
-        'b': {'name': 'b', 'type': 'string'},
-        'c': {'name': 'c', 'type': 'string'}},
-      getType(self.idl_basics, 'MyType1')['properties'])
-
-  def testMemberOrdering(self):
-    self.assertEquals(
-        ['x', 'y', 'z', 'a', 'b', 'c'],
-        getType(self.idl_basics, 'MyType1')['properties'].keys())
-
-  def testEnum(self):
-    schema = self.idl_basics
-    expected = {'enum': [{'name': 'name1', 'description': 'comment1'},
-                         {'name': 'name2'}],
-                'description': 'Enum description',
-                'type': 'string', 'id': 'EnumType'}
-    self.assertEquals(expected, getType(schema, expected['id']))
-
-    expected = [{'name': 'type', '$ref': 'EnumType'},
-                {'type': 'function', 'name': 'cb',
-                  'parameters':[{'name': 'type', '$ref': 'EnumType'}]}]
-    self.assertEquals(expected, getParams(schema, 'function13'))
-
-    expected = [{'items': {'$ref': 'EnumType'}, 'name': 'types',
-                 'type': 'array'}]
-    self.assertEquals(expected, getParams(schema, 'function14'))
-
-  def testScopedArguments(self):
-    schema = self.idl_basics
-    expected = [{'name': 'value', '$ref': 'idl_other_namespace.SomeType'}]
-    self.assertEquals(expected, getParams(schema, 'function20'))
-
-    expected = [{'items': {'$ref': 'idl_other_namespace.SomeType'},
-                 'name': 'values',
-                 'type': 'array'}]
-    self.assertEquals(expected, getParams(schema, 'function21'))
-
-    expected = [{'name': 'value',
-                 '$ref': 'idl_other_namespace.sub_namespace.AnotherType'}]
-    self.assertEquals(expected, getParams(schema, 'function22'))
-
-    expected = [{'items': {'$ref': 'idl_other_namespace.sub_namespace.'
-                                   'AnotherType'},
-                 'name': 'values',
-                 'type': 'array'}]
-    self.assertEquals(expected, getParams(schema, 'function23'))
-
-  def testNoCompile(self):
-    schema = self.idl_basics
-    func = getFunction(schema, 'function15')
-    self.assertTrue(func is not None)
-    self.assertTrue(func['nocompile'])
-
-  def testNoDocOnEnum(self):
-    schema = self.idl_basics
-    enum_with_nodoc = getType(schema, 'EnumTypeWithNoDoc')
-    self.assertTrue(enum_with_nodoc is not None)
-    self.assertTrue(enum_with_nodoc['nodoc'])
-
-  def testInternalNamespace(self):
-    idl_basics  = self.idl_basics
-    self.assertEquals('idl_basics', idl_basics['namespace'])
-    self.assertTrue(idl_basics['internal'])
-    self.assertFalse(idl_basics['nodoc'])
-
-  def testReturnTypes(self):
-    schema = self.idl_basics
-    self.assertEquals({'name': 'function24', 'type': 'integer'},
-                      getReturns(schema, 'function24'))
-    self.assertEquals({'name': 'function25', '$ref': 'MyType1',
-                       'optional': True},
-                      getReturns(schema, 'function25'))
-    self.assertEquals({'name': 'function26', 'type': 'array',
-                       'items': {'$ref': 'MyType1'}},
-                      getReturns(schema, 'function26'))
-    self.assertEquals({'name': 'function27', '$ref': 'EnumType',
-                       'optional': True},
-                      getReturns(schema, 'function27'))
-    self.assertEquals({'name': 'function28', 'type': 'array',
-                       'items': {'$ref': 'EnumType'}},
-                      getReturns(schema, 'function28'))
-    self.assertEquals({'name': 'function29', '$ref':
-                       'idl_other_namespace.SomeType',
-                       'optional': True},
-                      getReturns(schema, 'function29'))
-    self.assertEquals({'name': 'function30', 'type': 'array',
-                       'items': {'$ref': 'idl_other_namespace.SomeType'}},
-                      getReturns(schema, 'function30'))
-
-  def testChromeOSPlatformsNamespace(self):
-    schema = idl_schema.Load('test/idl_namespace_chromeos.idl')[0]
-    self.assertEquals('idl_namespace_chromeos', schema['namespace'])
-    expected = ['chromeos']
-    self.assertEquals(expected, schema['platforms'])
-
-  def testAllPlatformsNamespace(self):
-    schema = idl_schema.Load('test/idl_namespace_all_platforms.idl')[0]
-    self.assertEquals('idl_namespace_all_platforms', schema['namespace'])
-    expected = ['chromeos', 'chromeos_touch', 'linux', 'mac', 'win']
-    self.assertEquals(expected, schema['platforms'])
-
-  def testNonSpecificPlatformsNamespace(self):
-    schema = idl_schema.Load('test/idl_namespace_non_specific_platforms.idl')[0]
-    self.assertEquals('idl_namespace_non_specific_platforms',
-                      schema['namespace'])
-    expected = None
-    self.assertEquals(expected, schema['platforms'])
-
-  def testSpecificImplementNamespace(self):
-    schema = idl_schema.Load('test/idl_namespace_specific_implement.idl')[0]
-    self.assertEquals('idl_namespace_specific_implement',
-                      schema['namespace'])
-    expected = 'idl_namespace_specific_implement.idl'
-    self.assertEquals(expected, schema['compiler_options']['implemented_in'])
-
-  def testSpecificImplementOnChromeOSNamespace(self):
-    schema = idl_schema.Load(
-        'test/idl_namespace_specific_implement_chromeos.idl')[0]
-    self.assertEquals('idl_namespace_specific_implement_chromeos',
-                      schema['namespace'])
-    expected_implemented_path = 'idl_namespace_specific_implement_chromeos.idl'
-    expected_platform = ['chromeos']
-    self.assertEquals(expected_implemented_path,
-                      schema['compiler_options']['implemented_in'])
-    self.assertEquals(expected_platform, schema['platforms'])
-
-  def testCallbackComment(self):
-    schema = self.idl_basics
-    self.assertEquals('A comment on a callback.',
-                      getParams(schema, 'function16')[0]['description'])
-    self.assertEquals(
-        'A parameter.',
-        getParams(schema, 'function16')[0]['parameters'][0]['description'])
-    self.assertEquals(
-        'Just a parameter comment, with no comment on the callback.',
-        getParams(schema, 'function17')[0]['parameters'][0]['description'])
-    self.assertEquals(
-        'Override callback comment.',
-        getParams(schema, 'function18')[0]['description'])
-
-  def testFunctionComment(self):
-    schema = self.idl_basics
-    func = getFunction(schema, 'function3')
-    self.assertEquals(('This comment should appear in the documentation, '
-                       'despite occupying multiple lines.'),
-                      func['description'])
-    self.assertEquals(
-        [{'description': ('So should this comment about the argument. '
-                          '<em>HTML</em> is fine too.'),
-          'name': 'arg',
-          '$ref': 'MyType1'}],
-        func['parameters'])
-    func = getFunction(schema, 'function4')
-    self.assertEquals(
-        '<p>This tests if "double-quotes" are escaped correctly.</p>'
-        '<p>It also tests a comment with two newlines.</p>',
-        func['description'])
-
-  def testReservedWords(self):
-    schema = idl_schema.Load('test/idl_reserved_words.idl')[0]
-
-    foo_type = getType(schema, 'Foo')
-    self.assertEquals([{'name': 'float'}, {'name': 'DOMString'}],
-                      foo_type['enum'])
-
-    enum_type = getType(schema, 'enum')
-    self.assertEquals([{'name': 'callback'}, {'name': 'namespace'}],
-                      enum_type['enum'])
-
-    dictionary = getType(schema, 'dictionary')
-    self.assertEquals('integer', dictionary['properties']['long']['type'])
-
-    mytype = getType(schema, 'MyType')
-    self.assertEquals('string', mytype['properties']['interface']['type'])
-
-    params = getParams(schema, 'static')
-    self.assertEquals('Foo', params[0]['$ref'])
-    self.assertEquals('enum', params[1]['$ref'])
-
-  def testObjectTypes(self):
-    schema = idl_schema.Load('test/idl_object_types.idl')[0]
-
-    foo_type = getType(schema, 'FooType')
-    self.assertEquals('object', foo_type['type'])
-    self.assertEquals('integer', foo_type['properties']['x']['type'])
-    self.assertEquals('object', foo_type['properties']['y']['type'])
-    self.assertEquals(
-        'any',
-        foo_type['properties']['y']['additionalProperties']['type'])
-    self.assertEquals('object', foo_type['properties']['z']['type'])
-    self.assertEquals(
-        'any',
-        foo_type['properties']['z']['additionalProperties']['type'])
-    self.assertEquals('Window', foo_type['properties']['z']['isInstanceOf'])
-
-    bar_type = getType(schema, 'BarType')
-    self.assertEquals('object', bar_type['type'])
-    self.assertEquals('any', bar_type['properties']['x']['type'])
-
-  def testObjectTypesInFunctions(self):
-    schema = idl_schema.Load('test/idl_object_types.idl')[0]
-
-    params = getParams(schema, 'objectFunction1')
-    self.assertEquals('object', params[0]['type'])
-    self.assertEquals('any', params[0]['additionalProperties']['type'])
-    self.assertEquals('ImageData', params[0]['isInstanceOf'])
-
-    params = getParams(schema, 'objectFunction2')
-    self.assertEquals('any', params[0]['type'])
-
-  def testObjectTypesWithOptionalFields(self):
-    schema = idl_schema.Load('test/idl_object_types.idl')[0]
-
-    baz_type = getType(schema, 'BazType')
-    self.assertEquals(True, baz_type['properties']['x']['optional'])
-    self.assertEquals('integer', baz_type['properties']['x']['type'])
-    self.assertEquals(True, baz_type['properties']['foo']['optional'])
-    self.assertEquals('FooType', baz_type['properties']['foo']['$ref'])
-
-  def testObjectTypesWithUnions(self):
-    schema = idl_schema.Load('test/idl_object_types.idl')[0]
-
-    union_type = getType(schema, 'UnionType')
-    expected = {
-                 'type': 'object',
-                 'id': 'UnionType',
-                 'properties': {
-                   'x': {
-                     'name': 'x',
-                     'optional': True,
-                     'choices': [
-                       {'type': 'integer'},
-                       {'$ref': 'FooType'},
-                     ]
-                   },
-                   'y': {
-                     'name': 'y',
-                     'choices': [
-                       {'type': 'string'},
-                       {'type': 'object',
-                        'additionalProperties': {'type': 'any'}}
-                     ]
-                   },
-                   'z': {
-                     'name': 'z',
-                     'choices': [
-                       {'type': 'object', 'isInstanceOf': 'ImageData',
-                        'additionalProperties': {'type': 'any'}},
-                       {'type': 'integer'}
-                     ]
-                   }
-                 },
-               }
-
-    self.assertEquals(expected, union_type)
-
-  def testUnionsWithModifiers(self):
-    schema = idl_schema.Load('test/idl_object_types.idl')[0]
-
-    union_type = getType(schema, 'ModifiedUnionType')
-    expected = {
-                 'type': 'object',
-                 'id': 'ModifiedUnionType',
-                 'properties': {
-                   'x': {
-                     'name': 'x',
-                     'nodoc': True,
-                     'choices': [
-                       {'type': 'integer'},
-                       {'type': 'string'}
-                     ]
-                   }
-                 }
-               }
-
-    self.assertEquals(expected, union_type)
-
-  def testUnionsWithFunctions(self):
-    schema = idl_schema.Load('test/idl_function_types.idl')[0]
-
-    union_params = getParams(schema, 'union_params')
-    expected = [{
-                 'name': 'x',
-                 'choices': [
-                   {'type': 'integer'},
-                   {'type': 'string'}
-                 ]
-               }]
-
-    self.assertEquals(expected, union_params)
-
-  def testUnionsWithCallbacks(self):
-    schema = idl_schema.Load('test/idl_function_types.idl')[0]
-
-    blah_params = getParams(schema, 'blah')
-    expected = [{
-                 'type': 'function', 'name': 'callback', 'parameters': [{
-                   'name': 'x',
-                   'choices': [
-                     {'type': 'integer'},
-                     {'type': 'string'}
-                   ]}
-                 ]
-               }]
-    self.assertEquals(expected, blah_params)
-
-    badabish_params = getParams(schema, 'badabish')
-    expected = [{
-                 'type': 'function', 'name': 'callback', 'parameters': [{
-                   'name': 'x', 'optional': True, 'choices': [
-                     {'type': 'integer'},
-                     {'type': 'string'}
-                   ]
-                 }]
-               }]
-
-    self.assertEquals(expected, badabish_params)
-
-
-if __name__ == '__main__':
-  unittest.main()
diff --git a/tools/json_schema_compiler/json_parse.py b/tools/json_schema_compiler/json_parse.py
deleted file mode 100644
index 21a5a8f..0000000
--- a/tools/json_schema_compiler/json_parse.py
+++ /dev/null
@@ -1,61 +0,0 @@
-# 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.
-
-import json
-import os
-import sys
-
-_FILE_PATH = os.path.dirname(os.path.realpath(__file__))
-_SYS_PATH = sys.path[:]
-try:
-  _COMMENT_EATER_PATH = os.path.join(
-      _FILE_PATH, os.pardir, 'json_comment_eater')
-  sys.path.insert(0, _COMMENT_EATER_PATH)
-  import json_comment_eater
-finally:
-  sys.path = _SYS_PATH
-
-try:
-  from collections import OrderedDict
-
-  # Successfully imported, so we're running Python >= 2.7, and json.loads
-  # supports object_pairs_hook.
-  def Parse(json_str):
-    return json.loads(json_comment_eater.Nom(json_str),
-                      object_pairs_hook=OrderedDict)
-
-except ImportError:
-  # Failed to import, so we're running Python < 2.7, and json.loads doesn't
-  # support object_pairs_hook. simplejson however does, but it's slow.
-  #
-  # TODO(cduvall/kalman): Refuse to start the docs server in this case, but
-  # let json-schema-compiler do its thing.
-  #logging.warning('Using simplejson to parse, this might be slow! Upgrade to '
-  #                'Python 2.7.')
-
-  _SYS_PATH = sys.path[:]
-  try:
-    _SIMPLE_JSON_PATH = os.path.join(_FILE_PATH,
-                                     os.pardir,
-                                     os.pardir,
-                                     'third_party')
-    sys.path.insert(0, _SIMPLE_JSON_PATH)
-    # Add this path in case this is being used in the docs server.
-    sys.path.insert(0, os.path.join(_FILE_PATH,
-                                    os.pardir,
-                                    os.pardir,
-                                    'third_party',
-                                    'json_schema_compiler'))
-    import simplejson
-    from simplejson import OrderedDict
-  finally:
-    sys.path = _SYS_PATH
-
-  def Parse(json_str):
-    return simplejson.loads(json_comment_eater.Nom(json_str),
-                            object_pairs_hook=OrderedDict)
-
-
-def IsDict(item):
-  return isinstance(item, (dict, OrderedDict))
diff --git a/tools/json_schema_compiler/json_schema.py b/tools/json_schema_compiler/json_schema.py
deleted file mode 100644
index bb4e9c4..0000000
--- a/tools/json_schema_compiler/json_schema.py
+++ /dev/null
@@ -1,57 +0,0 @@
-# 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.
-
-import copy
-
-import json_parse
-
-
-def DeleteNodes(item, delete_key=None, matcher=None):
-  """Deletes certain nodes in item, recursively. If |delete_key| is set, all
-  dicts with |delete_key| as an attribute are deleted. If a callback is passed
-  as |matcher|, |DeleteNodes| will delete all dicts for which matcher(dict)
-  returns True.
-  """
-  assert (delete_key is not None) != (matcher is not None)
-
-  def ShouldDelete(thing):
-    return json_parse.IsDict(thing) and (
-        delete_key is not None and delete_key in thing or
-        matcher is not None and matcher(thing))
-
-  if json_parse.IsDict(item):
-    toDelete = []
-    for key, value in item.items():
-      if ShouldDelete(value):
-        toDelete.append(key)
-      else:
-        DeleteNodes(value, delete_key, matcher)
-    for key in toDelete:
-      del item[key]
-  elif type(item) == list:
-    item[:] = [DeleteNodes(thing, delete_key, matcher)
-        for thing in item if not ShouldDelete(thing)]
-
-  return item
-
-
-def Load(filename):
-  with open(filename, 'r') as handle:
-    schemas = json_parse.Parse(handle.read())
-  return schemas
-
-
-# A dictionary mapping |filename| to the object resulting from loading the JSON
-# at |filename|.
-_cache = {}
-
-
-def CachedLoad(filename):
-  """Equivalent to Load(filename), but caches results for subsequent calls"""
-  if filename not in _cache:
-    _cache[filename] = Load(filename)
-  # Return a copy of the object so that any changes a caller makes won't affect
-  # the next caller.
-  return copy.deepcopy(_cache[filename])
-
diff --git a/tools/json_schema_compiler/json_schema_test.py b/tools/json_schema_compiler/json_schema_test.py
deleted file mode 100755
index edbb06e..0000000
--- a/tools/json_schema_compiler/json_schema_test.py
+++ /dev/null
@@ -1,99 +0,0 @@
-#!/usr/bin/env python
-# 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.
-
-import json_schema
-import unittest
-
-class JsonSchemaUnittest(unittest.TestCase):
-  def testNocompile(self):
-    compiled = [
-      {
-        "namespace": "compile",
-        "description": "The compile API.",
-        "functions": [],
-        "types":     {}
-      },
-
-      {
-        "namespace": "functions",
-        "description": "The functions API.",
-        "functions": [
-          {
-            "id": "two"
-          },
-          {
-            "id": "four"
-          }
-        ],
-
-        "types": {
-          "one": { "key": "value" }
-        }
-      },
-
-      {
-        "namespace": "types",
-        "description": "The types API.",
-        "functions": [
-          { "id": "one" }
-        ],
-        "types": {
-          "two": {
-            "key": "value"
-          },
-          "four": {
-            "key": "value"
-          }
-        }
-      },
-
-      {
-        "namespace": "nested",
-        "description": "The nested API.",
-        "properties": {
-          "sync": {
-            "functions": [
-              {
-                "id": "two"
-              },
-              {
-                "id": "four"
-              }
-            ],
-            "types": {
-              "two": {
-                "key": "value"
-              },
-              "four": {
-                "key": "value"
-              }
-            }
-          }
-        }
-      }
-    ]
-
-    schema = json_schema.CachedLoad('test/json_schema_test.json')
-    self.assertEquals(compiled, json_schema.DeleteNodes(schema, 'nocompile'))
-
-    def should_delete(value):
-      return isinstance(value, dict) and not value.get('valid', True)
-    expected = [
-      {'one': {'test': 'test'}},
-      {'valid': True},
-      {}
-    ]
-    given = [
-      {'one': {'test': 'test'}, 'two': {'valid': False}},
-      {'valid': True},
-      {},
-      {'valid': False}
-    ]
-    self.assertEquals(
-        expected, json_schema.DeleteNodes(given, matcher=should_delete))
-
-
-if __name__ == '__main__':
-  unittest.main()
diff --git a/tools/json_schema_compiler/memoize.py b/tools/json_schema_compiler/memoize.py
deleted file mode 100644
index 228e7e3..0000000
--- a/tools/json_schema_compiler/memoize.py
+++ /dev/null
@@ -1,14 +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.
-
-def memoize(fn):
-  '''Decorates |fn| to memoize.
-  '''
-  memory = {}
-  def impl(*args, **optargs):
-    full_args = args + tuple(optargs.iteritems())
-    if full_args not in memory:
-      memory[full_args] = fn(*args, **optargs)
-    return memory[full_args]
-  return impl
diff --git a/tools/json_schema_compiler/model.py b/tools/json_schema_compiler/model.py
deleted file mode 100644
index 16530e7..0000000
--- a/tools/json_schema_compiler/model.py
+++ /dev/null
@@ -1,605 +0,0 @@
-# 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.
-
-import os.path
-
-from json_parse import OrderedDict
-from memoize import memoize
-
-
-class ParseException(Exception):
-  """Thrown when data in the model is invalid.
-  """
-  def __init__(self, parent, message):
-    hierarchy = _GetModelHierarchy(parent)
-    hierarchy.append(message)
-    Exception.__init__(
-        self, 'Model parse exception at:\n' + '\n'.join(hierarchy))
-
-
-class Model(object):
-  """Model of all namespaces that comprise an API.
-
-  Properties:
-  - |namespaces| a map of a namespace name to its model.Namespace
-  """
-  def __init__(self):
-    self.namespaces = {}
-
-  def AddNamespace(self,
-                   json,
-                   source_file,
-                   include_compiler_options=False,
-                   environment=None):
-    """Add a namespace's json to the model and returns the namespace.
-    """
-    namespace = Namespace(json,
-                          source_file,
-                          include_compiler_options=include_compiler_options,
-                          environment=environment)
-    self.namespaces[namespace.name] = namespace
-    return namespace
-
-
-def CreateFeature(name, model):
-  if isinstance(model, dict):
-    return SimpleFeature(name, model)
-  return ComplexFeature(name, [SimpleFeature(name, child) for child in model])
-
-
-class ComplexFeature(object):
-  """A complex feature which may be made of several simple features.
-
-  Properties:
-  - |name| the name of the feature
-  - |unix_name| the unix_name of the feature
-  - |feature_list| a list of simple features which make up the feature
-  """
-  def __init__(self, feature_name, features):
-    self.name = feature_name
-    self.unix_name = UnixName(self.name)
-    self.feature_list = features
-
-class SimpleFeature(object):
-  """A simple feature, which can make up a complex feature, as specified in
-  files such as chrome/common/extensions/api/_permission_features.json.
-
-  Properties:
-  - |name| the name of the feature
-  - |unix_name| the unix_name of the feature
-  - |channel| the channel where the feature is released
-  - |extension_types| the types which can use the feature
-  - |whitelist| a list of extensions allowed to use the feature
-  """
-  def __init__(self, feature_name, feature_def):
-    self.name = feature_name
-    self.unix_name = UnixName(self.name)
-    self.channel = feature_def['channel']
-    self.extension_types = feature_def['extension_types']
-    self.whitelist = feature_def.get('whitelist')
-
-
-class Namespace(object):
-  """An API namespace.
-
-  Properties:
-  - |name| the name of the namespace
-  - |description| the description of the namespace
-  - |deprecated| a reason and possible alternative for a deprecated api
-  - |unix_name| the unix_name of the namespace
-  - |source_file| the file that contained the namespace definition
-  - |source_file_dir| the directory component of |source_file|
-  - |source_file_filename| the filename component of |source_file|
-  - |platforms| if not None, the list of platforms that the namespace is
-                available to
-  - |types| a map of type names to their model.Type
-  - |functions| a map of function names to their model.Function
-  - |events| a map of event names to their model.Function
-  - |properties| a map of property names to their model.Property
-  - |compiler_options| the compiler_options dict, only not empty if
-                       |include_compiler_options| is True
-  """
-  def __init__(self,
-               json,
-               source_file,
-               include_compiler_options=False,
-               environment=None):
-    self.name = json['namespace']
-    if 'description' not in json:
-      # TODO(kalman): Go back to throwing an error here.
-      print('%s must have a "description" field. This will appear '
-                       'on the API summary page.' % self.name)
-      json['description'] = ''
-    self.description = json['description']
-    self.deprecated = json.get('deprecated', None)
-    self.unix_name = UnixName(self.name)
-    self.source_file = source_file
-    self.source_file_dir, self.source_file_filename = os.path.split(source_file)
-    self.short_filename = os.path.basename(source_file).split('.')[0]
-    self.parent = None
-    self.platforms = _GetPlatforms(json)
-    toplevel_origin = Origin(from_client=True, from_json=True)
-    self.types = _GetTypes(self, json, self, toplevel_origin)
-    self.functions = _GetFunctions(self, json, self)
-    self.events = _GetEvents(self, json, self)
-    self.properties = _GetProperties(self, json, self, toplevel_origin)
-    if include_compiler_options:
-      self.compiler_options = json.get('compiler_options', {})
-    else:
-      self.compiler_options = {}
-    self.environment = environment
-    self.documentation_options = json.get('documentation_options', {})
-
-
-class Origin(object):
-  """Stores the possible origin of model object as a pair of bools. These are:
-
-  |from_client| indicating that instances can originate from users of
-                generated code (for example, function results), or
-  |from_json|   indicating that instances can originate from the JSON (for
-                example, function parameters)
-
-  It is possible for model objects to originate from both the client and json,
-  for example Types defined in the top-level schema, in which case both
-  |from_client| and |from_json| would be True.
-  """
-  def __init__(self, from_client=False, from_json=False):
-    if not from_client and not from_json:
-      raise ValueError('One of from_client or from_json must be true')
-    self.from_client = from_client
-    self.from_json = from_json
-
-
-class Type(object):
-  """A Type defined in the json.
-
-  Properties:
-  - |name| the type name
-  - |namespace| the Type's namespace
-  - |description| the description of the type (if provided)
-  - |properties| a map of property unix_names to their model.Property
-  - |functions| a map of function names to their model.Function
-  - |events| a map of event names to their model.Event
-  - |origin| the Origin of the type
-  - |property_type| the PropertyType of this Type
-  - |item_type| if this is an array, the type of items in the array
-  - |simple_name| the name of this Type without a namespace
-  - |additional_properties| the type of the additional properties, if any is
-                            specified
-  """
-  def __init__(self,
-               parent,
-               name,
-               json,
-               namespace,
-               origin):
-    self.name = name
-    self.namespace = namespace
-    self.simple_name = _StripNamespace(self.name, namespace)
-    self.unix_name = UnixName(self.name)
-    self.description = json.get('description', None)
-    self.origin = origin
-    self.parent = parent
-    self.instance_of = json.get('isInstanceOf', None)
-
-    # TODO(kalman): Only objects need functions/events/properties, but callers
-    # assume that all types have them. Fix this.
-    self.functions = _GetFunctions(self, json, namespace)
-    self.events = _GetEvents(self, json, namespace)
-    self.properties = _GetProperties(self, json, namespace, origin)
-
-    json_type = json.get('type', None)
-    if json_type == 'array':
-      self.property_type = PropertyType.ARRAY
-      self.item_type = Type(
-          self, '%sType' % name, json['items'], namespace, origin)
-    elif '$ref' in json:
-      self.property_type = PropertyType.REF
-      self.ref_type = json['$ref']
-    elif 'enum' in json and json_type == 'string':
-      self.property_type = PropertyType.ENUM
-      self.enum_values = [EnumValue(value) for value in json['enum']]
-      self.cpp_enum_prefix_override = json.get('cpp_enum_prefix_override', None)
-    elif json_type == 'any':
-      self.property_type = PropertyType.ANY
-    elif json_type == 'binary':
-      self.property_type = PropertyType.BINARY
-    elif json_type == 'boolean':
-      self.property_type = PropertyType.BOOLEAN
-    elif json_type == 'integer':
-      self.property_type = PropertyType.INTEGER
-    elif (json_type == 'double' or
-          json_type == 'number'):
-      self.property_type = PropertyType.DOUBLE
-    elif json_type == 'string':
-      self.property_type = PropertyType.STRING
-    elif 'choices' in json:
-      self.property_type = PropertyType.CHOICES
-      def generate_type_name(type_json):
-        if 'items' in type_json:
-          return '%ss' % generate_type_name(type_json['items'])
-        if '$ref' in type_json:
-          return type_json['$ref']
-        if 'type' in type_json:
-          return type_json['type']
-        return None
-      self.choices = [
-          Type(self,
-               generate_type_name(choice) or 'choice%s' % i,
-               choice,
-               namespace,
-               origin)
-          for i, choice in enumerate(json['choices'])]
-    elif json_type == 'object':
-      if not (
-          'isInstanceOf' in json or
-          'properties' in json or
-          'additionalProperties' in json or
-          'functions' in json or
-          'events' in json):
-        raise ParseException(self, name + " has no properties or functions")
-      self.property_type = PropertyType.OBJECT
-      additional_properties_json = json.get('additionalProperties', None)
-      if additional_properties_json is not None:
-        self.additional_properties = Type(self,
-                                          'additionalProperties',
-                                          additional_properties_json,
-                                          namespace,
-                                          origin)
-      else:
-        self.additional_properties = None
-    elif json_type == 'function':
-      self.property_type = PropertyType.FUNCTION
-      # Sometimes we might have an unnamed function, e.g. if it's a property
-      # of an object. Use the name of the property in that case.
-      function_name = json.get('name', name)
-      self.function = Function(self, function_name, json, namespace, origin)
-    else:
-      raise ParseException(self, 'Unsupported JSON type %s' % json_type)
-
-
-class Function(object):
-  """A Function defined in the API.
-
-  Properties:
-  - |name| the function name
-  - |platforms| if not None, the list of platforms that the function is
-                available to
-  - |params| a list of parameters to the function (order matters). A separate
-             parameter is used for each choice of a 'choices' parameter
-  - |deprecated| a reason and possible alternative for a deprecated function
-  - |description| a description of the function (if provided)
-  - |callback| the callback parameter to the function. There should be exactly
-               one
-  - |optional| whether the Function is "optional"; this only makes sense to be
-               present when the Function is representing a callback property
-  - |simple_name| the name of this Function without a namespace
-  - |returns| the return type of the function; None if the function does not
-    return a value
-  """
-  def __init__(self,
-               parent,
-               name,
-               json,
-               namespace,
-               origin):
-    self.name = name
-    self.simple_name = _StripNamespace(self.name, namespace)
-    self.platforms = _GetPlatforms(json)
-    self.params = []
-    self.description = json.get('description')
-    self.deprecated = json.get('deprecated')
-    self.callback = None
-    self.optional = json.get('optional', False)
-    self.parent = parent
-    self.nocompile = json.get('nocompile')
-    options = json.get('options', {})
-    self.conditions = options.get('conditions', [])
-    self.actions = options.get('actions', [])
-    self.supports_listeners = options.get('supportsListeners', True)
-    self.supports_rules = options.get('supportsRules', False)
-    self.supports_dom = options.get('supportsDom', False)
-
-    def GeneratePropertyFromParam(p):
-      return Property(self, p['name'], p, namespace, origin)
-
-    self.filters = [GeneratePropertyFromParam(filter)
-                    for filter in json.get('filters', [])]
-    callback_param = None
-    for param in json.get('parameters', []):
-      if param.get('type') == 'function':
-        if callback_param:
-          # No ParseException because the webstore has this.
-          # Instead, pretend all intermediate callbacks are properties.
-          self.params.append(GeneratePropertyFromParam(callback_param))
-        callback_param = param
-      else:
-        self.params.append(GeneratePropertyFromParam(param))
-
-    if callback_param:
-      self.callback = Function(self,
-                               callback_param['name'],
-                               callback_param,
-                               namespace,
-                               Origin(from_client=True))
-
-    self.returns = None
-    if 'returns' in json:
-      self.returns = Type(self,
-                          '%sReturnType' % name,
-                          json['returns'],
-                          namespace,
-                          origin)
-
-
-class Property(object):
-  """A property of a type OR a parameter to a function.
-  Properties:
-  - |name| name of the property as in the json. This shouldn't change since
-    it is the key used to access DictionaryValues
-  - |unix_name| the unix_style_name of the property. Used as variable name
-  - |optional| a boolean representing whether the property is optional
-  - |description| a description of the property (if provided)
-  - |type_| the model.Type of this property
-  - |simple_name| the name of this Property without a namespace
-  - |deprecated| a reason and possible alternative for a deprecated property
-  """
-  def __init__(self, parent, name, json, namespace, origin):
-    """Creates a Property from JSON.
-    """
-    self.parent = parent
-    self.name = name
-    self._unix_name = UnixName(self.name)
-    self._unix_name_used = False
-    self.origin = origin
-    self.simple_name = _StripNamespace(self.name, namespace)
-    self.description = json.get('description', None)
-    self.optional = json.get('optional', None)
-    self.instance_of = json.get('isInstanceOf', None)
-    self.deprecated = json.get('deprecated')
-
-    # HACK: only support very specific value types.
-    is_allowed_value = (
-        '$ref' not in json and
-        ('type' not in json or json['type'] == 'integer'
-                            or json['type'] == 'string'))
-
-    self.value = None
-    if 'value' in json and is_allowed_value:
-      self.value = json['value']
-      if 'type' not in json:
-        # Sometimes the type of the value is left out, and we need to figure
-        # it out for ourselves.
-        if isinstance(self.value, int):
-          json['type'] = 'integer'
-        elif isinstance(self.value, basestring):
-          json['type'] = 'string'
-        else:
-          # TODO(kalman): support more types as necessary.
-          raise ParseException(
-              parent,
-              '"%s" is not a supported type for "value"' % type(self.value))
-
-    self.type_ = Type(parent, name, json, namespace, origin)
-
-  def GetUnixName(self):
-    """Gets the property's unix_name. Raises AttributeError if not set.
-    """
-    if not self._unix_name:
-      raise AttributeError('No unix_name set on %s' % self.name)
-    self._unix_name_used = True
-    return self._unix_name
-
-  def SetUnixName(self, unix_name):
-    """Set the property's unix_name. Raises AttributeError if the unix_name has
-    already been used (GetUnixName has been called).
-    """
-    if unix_name == self._unix_name:
-      return
-    if self._unix_name_used:
-      raise AttributeError(
-          'Cannot set the unix_name on %s; '
-          'it is already used elsewhere as %s' %
-          (self.name, self._unix_name))
-    self._unix_name = unix_name
-
-  unix_name = property(GetUnixName, SetUnixName)
-
-class EnumValue(object):
-  """A single value from an enum.
-  Properties:
-  - |name| name of the property as in the json.
-  - |description| a description of the property (if provided)
-  """
-  def __init__(self, json):
-    if isinstance(json, dict):
-      self.name = json['name']
-      self.description = json.get('description')
-    else:
-      self.name = json
-      self.description = None
-
-  def CamelName(self):
-    return CamelName(self.name)
-
-class _Enum(object):
-  """Superclass for enum types with a "name" field, setting up repr/eq/ne.
-  Enums need to do this so that equality/non-equality work over pickling.
-  """
-  @staticmethod
-  def GetAll(cls):
-    """Yields all _Enum objects declared in |cls|.
-    """
-    for prop_key in dir(cls):
-      prop_value = getattr(cls, prop_key)
-      if isinstance(prop_value, _Enum):
-        yield prop_value
-
-  def __init__(self, name):
-    self.name = name
-
-  def __eq__(self, other):
-    return type(other) == type(self) and other.name == self.name
-  def __ne__(self, other):
-    return not (self == other)
-
-  def __repr__(self):
-    return self.name
-
-  def __str__(self):
-    return repr(self)
-
-
-class _PropertyTypeInfo(_Enum):
-  def __init__(self, is_fundamental, name):
-    _Enum.__init__(self, name)
-    self.is_fundamental = is_fundamental
-
-
-class PropertyType(object):
-  """Enum of different types of properties/parameters.
-  """
-  ANY = _PropertyTypeInfo(False, "any")
-  ARRAY = _PropertyTypeInfo(False, "array")
-  BINARY = _PropertyTypeInfo(False, "binary")
-  BOOLEAN = _PropertyTypeInfo(True, "boolean")
-  CHOICES = _PropertyTypeInfo(False, "choices")
-  DOUBLE = _PropertyTypeInfo(True, "double")
-  ENUM = _PropertyTypeInfo(False, "enum")
-  FUNCTION = _PropertyTypeInfo(False, "function")
-  INT64 = _PropertyTypeInfo(True, "int64")
-  INTEGER = _PropertyTypeInfo(True, "integer")
-  OBJECT = _PropertyTypeInfo(False, "object")
-  REF = _PropertyTypeInfo(False, "ref")
-  STRING = _PropertyTypeInfo(True, "string")
-
-
-@memoize
-def UnixName(name):
-  '''Returns the unix_style name for a given lowerCamelCase string.
-  '''
-  unix_name = []
-  for i, c in enumerate(name):
-    if c.isupper() and i > 0 and name[i - 1] != '_':
-      # Replace lowerUpper with lower_Upper.
-      if name[i - 1].islower():
-        unix_name.append('_')
-      # Replace ACMEWidgets with ACME_Widgets
-      elif i + 1 < len(name) and name[i + 1].islower():
-        unix_name.append('_')
-    if c == '.':
-      # Replace hello.world with hello_world.
-      unix_name.append('_')
-    else:
-      # Everything is lowercase.
-      unix_name.append(c.lower())
-  return ''.join(unix_name)
-
-
-@memoize
-def CamelName(snake):
-  ''' Converts a snake_cased_string to a camelCasedOne. '''
-  pieces = snake.split('_')
-  camel = []
-  for i, piece in enumerate(pieces):
-    if i == 0:
-      camel.append(piece)
-    else:
-      camel.append(piece.capitalize())
-  return ''.join(camel)
-
-
-def _StripNamespace(name, namespace):
-  if name.startswith(namespace.name + '.'):
-    return name[len(namespace.name + '.'):]
-  return name
-
-
-def _GetModelHierarchy(entity):
-  """Returns the hierarchy of the given model entity."""
-  hierarchy = []
-  while entity is not None:
-    hierarchy.append(getattr(entity, 'name', repr(entity)))
-    if isinstance(entity, Namespace):
-      hierarchy.insert(0, '  in %s' % entity.source_file)
-    entity = getattr(entity, 'parent', None)
-  hierarchy.reverse()
-  return hierarchy
-
-
-def _GetTypes(parent, json, namespace, origin):
-  """Creates Type objects extracted from |json|.
-  """
-  types = OrderedDict()
-  for type_json in json.get('types', []):
-    type_ = Type(parent, type_json['id'], type_json, namespace, origin)
-    types[type_.name] = type_
-  return types
-
-
-def _GetFunctions(parent, json, namespace):
-  """Creates Function objects extracted from |json|.
-  """
-  functions = OrderedDict()
-  for function_json in json.get('functions', []):
-    function = Function(parent,
-                        function_json['name'],
-                        function_json,
-                        namespace,
-                        Origin(from_json=True))
-    functions[function.name] = function
-  return functions
-
-
-def _GetEvents(parent, json, namespace):
-  """Creates Function objects generated from the events in |json|.
-  """
-  events = OrderedDict()
-  for event_json in json.get('events', []):
-    event = Function(parent,
-                     event_json['name'],
-                     event_json,
-                     namespace,
-                     Origin(from_client=True))
-    events[event.name] = event
-  return events
-
-
-def _GetProperties(parent, json, namespace, origin):
-  """Generates Property objects extracted from |json|.
-  """
-  properties = OrderedDict()
-  for name, property_json in json.get('properties', {}).items():
-    properties[name] = Property(parent, name, property_json, namespace, origin)
-  return properties
-
-
-class _PlatformInfo(_Enum):
-  def __init__(self, name):
-    _Enum.__init__(self, name)
-
-
-class Platforms(object):
-  """Enum of the possible platforms.
-  """
-  CHROMEOS = _PlatformInfo("chromeos")
-  CHROMEOS_TOUCH = _PlatformInfo("chromeos_touch")
-  LINUX = _PlatformInfo("linux")
-  MAC = _PlatformInfo("mac")
-  WIN = _PlatformInfo("win")
-
-
-def _GetPlatforms(json):
-  if 'platforms' not in json or json['platforms'] == None:
-    return None
-  # Sanity check: platforms should not be an empty list.
-  if not json['platforms']:
-    raise ValueError('"platforms" cannot be an empty list')
-  platforms = []
-  for platform_name in json['platforms']:
-    for platform_enum in _Enum.GetAll(Platforms):
-      if platform_name == platform_enum.name:
-        platforms.append(platform_enum)
-        break
-  return platforms
diff --git a/tools/json_schema_compiler/model_test.py b/tools/json_schema_compiler/model_test.py
deleted file mode 100755
index 75ed9c5..0000000
--- a/tools/json_schema_compiler/model_test.py
+++ /dev/null
@@ -1,147 +0,0 @@
-#!/usr/bin/env python
-# 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.
-
-from json_schema import CachedLoad
-from idl_schema import Load
-from model import Platforms
-import model
-import unittest
-
-class ModelTest(unittest.TestCase):
-  def setUp(self):
-    self.model = model.Model()
-    self.permissions_json = CachedLoad('test/permissions.json')
-    self.model.AddNamespace(self.permissions_json[0],
-        'path/to/permissions.json')
-    self.permissions = self.model.namespaces.get('permissions')
-    self.windows_json = CachedLoad('test/windows.json')
-    self.model.AddNamespace(self.windows_json[0],
-        'path/to/window.json')
-    self.windows = self.model.namespaces.get('windows')
-    self.tabs_json = CachedLoad('test/tabs.json')
-    self.model.AddNamespace(self.tabs_json[0],
-        'path/to/tabs.json')
-    self.tabs = self.model.namespaces.get('tabs')
-    self.idl_chromeos = Load('test/idl_namespace_chromeos.idl')
-    self.model.AddNamespace(self.idl_chromeos[0],
-        'path/to/idl_namespace_chromeos.idl')
-    self.idl_namespace_chromeos = self.model.namespaces.get(
-        'idl_namespace_chromeos')
-    self.idl_all_platforms = Load('test/idl_namespace_all_platforms.idl')
-    self.model.AddNamespace(self.idl_all_platforms[0],
-        'path/to/idl_namespace_all_platforms.idl')
-    self.idl_namespace_all_platforms = self.model.namespaces.get(
-        'idl_namespace_all_platforms')
-    self.idl_non_specific_platforms = Load(
-        'test/idl_namespace_non_specific_platforms.idl')
-    self.model.AddNamespace(self.idl_non_specific_platforms[0],
-        'path/to/idl_namespace_non_specific_platforms.idl')
-    self.idl_namespace_non_specific_platforms = self.model.namespaces.get(
-        'idl_namespace_non_specific_platforms')
-
-  def testNamespaces(self):
-    self.assertEquals(6, len(self.model.namespaces))
-    self.assertTrue(self.permissions)
-
-  def testHasFunctions(self):
-    self.assertEquals(["contains", "getAll", "remove", "request"],
-        sorted(self.permissions.functions.keys()))
-
-  def testHasTypes(self):
-    self.assertEquals(['Tab'], self.tabs.types.keys())
-    self.assertEquals(['Permissions'], self.permissions.types.keys())
-    self.assertEquals(['Window'], self.windows.types.keys())
-
-  def testHasProperties(self):
-    self.assertEquals(["active", "favIconUrl", "highlighted", "id",
-        "incognito", "index", "pinned", "selected", "status", "title", "url",
-        "windowId"],
-        sorted(self.tabs.types['Tab'].properties.keys()))
-
-  def testProperties(self):
-    string_prop = self.tabs.types['Tab'].properties['status']
-    self.assertEquals(model.PropertyType.STRING,
-                      string_prop.type_.property_type)
-    integer_prop = self.tabs.types['Tab'].properties['id']
-    self.assertEquals(model.PropertyType.INTEGER,
-                      integer_prop.type_.property_type)
-    array_prop = self.windows.types['Window'].properties['tabs']
-    self.assertEquals(model.PropertyType.ARRAY,
-                      array_prop.type_.property_type)
-    self.assertEquals(model.PropertyType.REF,
-                      array_prop.type_.item_type.property_type)
-    self.assertEquals('tabs.Tab', array_prop.type_.item_type.ref_type)
-    object_prop = self.tabs.functions['query'].params[0]
-    self.assertEquals(model.PropertyType.OBJECT,
-                      object_prop.type_.property_type)
-    self.assertEquals(
-        ["active", "highlighted", "pinned", "status", "title", "url",
-         "windowId", "windowType"],
-        sorted(object_prop.type_.properties.keys()))
-
-  def testChoices(self):
-    self.assertEquals(model.PropertyType.CHOICES,
-                      self.tabs.functions['move'].params[0].type_.property_type)
-
-  def testPropertyNotImplemented(self):
-    (self.permissions_json[0]['types'][0]
-        ['properties']['permissions']['type']) = 'something'
-    self.assertRaises(model.ParseException, self.model.AddNamespace,
-        self.permissions_json[0], 'path/to/something.json')
-
-  def testDescription(self):
-    self.assertFalse(
-        self.permissions.functions['contains'].params[0].description)
-    self.assertEquals('True if the extension has the specified permissions.',
-        self.permissions.functions['contains'].callback.params[0].description)
-
-  def testPropertyUnixName(self):
-    param = self.tabs.functions['move'].params[0]
-    self.assertEquals('tab_ids', param.unix_name)
-
-  def testUnixName(self):
-    expectations = {
-      'foo': 'foo',
-      'fooBar': 'foo_bar',
-      'fooBarBaz': 'foo_bar_baz',
-      'fooBARBaz': 'foo_bar_baz',
-      'fooBAR': 'foo_bar',
-      'FOO': 'foo',
-      'FOOBar': 'foo_bar',
-      'foo.bar': 'foo_bar',
-      'foo.BAR': 'foo_bar',
-      'foo.barBAZ': 'foo_bar_baz',
-      'foo_Bar_Baz_box': 'foo_bar_baz_box',
-      }
-    for name in expectations:
-      self.assertEquals(expectations[name], model.UnixName(name))
-
-  def testCamelName(self):
-    expectations = {
-      'foo': 'foo',
-      'fooBar': 'fooBar',
-      'foo_bar_baz': 'fooBarBaz',
-      'FOO_BAR': 'FOOBar',
-      'FOO_bar': 'FOOBar',
-      '_bar': 'Bar',
-      '_bar_baz': 'BarBaz',
-      'bar_': 'bar',
-      'bar_baz_': 'barBaz',
-      }
-    for testcase, expected in expectations.iteritems():
-      self.assertEquals(expected, model.CamelName(testcase))
-
-  def testPlatforms(self):
-    self.assertEqual([Platforms.CHROMEOS],
-                     self.idl_namespace_chromeos.platforms)
-    self.assertEqual(
-        [Platforms.CHROMEOS, Platforms.CHROMEOS_TOUCH, Platforms.LINUX,
-         Platforms.MAC, Platforms.WIN],
-        self.idl_namespace_all_platforms.platforms)
-    self.assertEqual(None,
-        self.idl_namespace_non_specific_platforms.platforms)
-
-if __name__ == '__main__':
-  unittest.main()
diff --git a/tools/json_schema_compiler/preview.py b/tools/json_schema_compiler/preview.py
deleted file mode 100755
index 050af96..0000000
--- a/tools/json_schema_compiler/preview.py
+++ /dev/null
@@ -1,364 +0,0 @@
-#!/usr/bin/env python
-
-# 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.
-"""Server for viewing the compiled C++ code from tools/json_schema_compiler.
-"""
-
-import cc_generator
-import code
-import cpp_type_generator
-import cpp_util
-import h_generator
-import idl_schema
-import json_schema
-import model
-import optparse
-import os
-import shlex
-import urlparse
-from highlighters import (
-    pygments_highlighter, none_highlighter, hilite_me_highlighter)
-from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
-from cpp_namespace_environment import CppNamespaceEnvironment
-from schema_loader import SchemaLoader
-
-
-class CompilerHandler(BaseHTTPRequestHandler):
-  """A HTTPRequestHandler that outputs the result of tools/json_schema_compiler.
-  """
-  def do_GET(self):
-    parsed_url = urlparse.urlparse(self.path)
-    request_path = self._GetRequestPath(parsed_url)
-
-    chromium_favicon = 'http://codereview.chromium.org/static/favicon.ico'
-
-    head = code.Code()
-    head.Append('<link rel="icon" href="%s">' % chromium_favicon)
-    head.Append('<link rel="shortcut icon" href="%s">' % chromium_favicon)
-
-    body = code.Code()
-
-    try:
-      if os.path.isdir(request_path):
-        self._ShowPanels(parsed_url, head, body)
-      else:
-        self._ShowCompiledFile(parsed_url, head, body)
-    finally:
-      self.wfile.write('<html><head>')
-      self.wfile.write(head.Render())
-      self.wfile.write('</head><body>')
-      self.wfile.write(body.Render())
-      self.wfile.write('</body></html>')
-
-  def _GetRequestPath(self, parsed_url, strip_nav=False):
-    """Get the relative path from the current directory to the requested file.
-    """
-    path = parsed_url.path
-    if strip_nav:
-      path = parsed_url.path.replace('/nav', '')
-    return os.path.normpath(os.curdir + path)
-
-  def _ShowPanels(self, parsed_url, head, body):
-    """Show the previewer frame structure.
-
-    Code panes are populated via XHR after links in the nav pane are clicked.
-    """
-    (head.Append('<style>')
-         .Append('body {')
-         .Append('  margin: 0;')
-         .Append('}')
-         .Append('.pane {')
-         .Append('  height: 100%;')
-         .Append('  overflow-x: auto;')
-         .Append('  overflow-y: scroll;')
-         .Append('  display: inline-block;')
-         .Append('}')
-         .Append('#nav_pane {')
-         .Append('  width: 20%;')
-         .Append('}')
-         .Append('#nav_pane ul {')
-         .Append('  list-style-type: none;')
-         .Append('  padding: 0 0 0 1em;')
-         .Append('}')
-         .Append('#cc_pane {')
-         .Append('  width: 40%;')
-         .Append('}')
-         .Append('#h_pane {')
-         .Append('  width: 40%;')
-         .Append('}')
-         .Append('</style>')
-    )
-
-    body.Append(
-        '<div class="pane" id="nav_pane">%s</div>'
-        '<div class="pane" id="h_pane"></div>'
-        '<div class="pane" id="cc_pane"></div>' %
-        self._RenderNavPane(parsed_url.path[1:])
-    )
-
-    # The Javascript that interacts with the nav pane and panes to show the
-    # compiled files as the URL or highlighting options change.
-    body.Append('''<script type="text/javascript">
-// Calls a function for each highlighter style <select> element.
-function forEachHighlighterStyle(callback) {
-  var highlighterStyles =
-      document.getElementsByClassName('highlighter_styles');
-  for (var i = 0; i < highlighterStyles.length; ++i)
-    callback(highlighterStyles[i]);
-}
-
-// Called when anything changes, such as the highlighter or hashtag.
-function updateEverything() {
-  var highlighters = document.getElementById('highlighters');
-  var highlighterName = highlighters.value;
-
-  // Cache in localStorage for when the page loads next.
-  localStorage.highlightersValue = highlighterName;
-
-  // Show/hide the highlighter styles.
-  var highlighterStyleName = '';
-  forEachHighlighterStyle(function(highlighterStyle) {
-    if (highlighterStyle.id === highlighterName + '_styles') {
-      highlighterStyle.removeAttribute('style')
-      highlighterStyleName = highlighterStyle.value;
-    } else {
-      highlighterStyle.setAttribute('style', 'display:none')
-    }
-
-    // Cache in localStorage for when the page next loads.
-    localStorage[highlighterStyle.id + 'Value'] = highlighterStyle.value;
-  });
-
-  // Populate the code panes.
-  function populateViaXHR(elementId, requestPath) {
-    var xhr = new XMLHttpRequest();
-    xhr.onreadystatechange = function() {
-      if (xhr.readyState != 4)
-        return;
-      if (xhr.status != 200) {
-        alert('XHR error to ' + requestPath);
-        return;
-      }
-      document.getElementById(elementId).innerHTML = xhr.responseText;
-    };
-    xhr.open('GET', requestPath, true);
-    xhr.send();
-  }
-
-  var targetName = window.location.hash;
-  targetName = targetName.substring('#'.length);
-  targetName = targetName.split('.', 1)[0]
-
-  if (targetName !== '') {
-    var basePath = window.location.pathname;
-    var query = 'highlighter=' + highlighterName + '&' +
-                'style=' + highlighterStyleName;
-    populateViaXHR('h_pane',  basePath + '/' + targetName + '.h?'  + query);
-    populateViaXHR('cc_pane', basePath + '/' + targetName + '.cc?' + query);
-  }
-}
-
-// Initial load: set the values of highlighter and highlighterStyles from
-// localStorage.
-(function() {
-var cachedValue = localStorage.highlightersValue;
-if (cachedValue)
-  document.getElementById('highlighters').value = cachedValue;
-
-forEachHighlighterStyle(function(highlighterStyle) {
-  var cachedValue = localStorage[highlighterStyle.id + 'Value'];
-  if (cachedValue)
-    highlighterStyle.value = cachedValue;
-});
-})();
-
-window.addEventListener('hashchange', updateEverything, false);
-updateEverything();
-</script>''')
-
-  def _ShowCompiledFile(self, parsed_url, head, body):
-    """Show the compiled version of a json or idl file given the path to the
-    compiled file.
-    """
-    api_model = model.Model()
-
-    request_path = self._GetRequestPath(parsed_url)
-    (file_root, file_ext) = os.path.splitext(request_path)
-    (filedir, filename) = os.path.split(file_root)
-
-    schema_loader = SchemaLoader("./",
-                                 filedir,
-                                 self.server.include_rules,
-                                 self.server.cpp_namespace_pattern)
-    try:
-      # Get main file.
-      namespace = schema_loader.ResolveNamespace(filename)
-      type_generator = cpp_type_generator.CppTypeGenerator(
-           api_model,
-           schema_loader,
-           namespace)
-
-      # Generate code
-      cpp_namespace = 'generated_api_schemas'
-      if file_ext == '.h':
-        cpp_code = (h_generator.HGenerator(type_generator)
-            .Generate(namespace).Render())
-      elif file_ext == '.cc':
-        cpp_code = (cc_generator.CCGenerator(type_generator)
-            .Generate(namespace).Render())
-      else:
-        self.send_error(404, "File not found: %s" % request_path)
-        return
-
-      # Do highlighting on the generated code
-      (highlighter_param, style_param) = self._GetHighlighterParams(parsed_url)
-      head.Append('<style>' +
-          self.server.highlighters[highlighter_param].GetCSS(style_param) +
-          '</style>')
-      body.Append(self.server.highlighters[highlighter_param]
-          .GetCodeElement(cpp_code, style_param))
-    except IOError:
-      self.send_error(404, "File not found: %s" % request_path)
-      return
-    except (TypeError, KeyError, AttributeError,
-        AssertionError, NotImplementedError) as error:
-      body.Append('<pre>')
-      body.Append('compiler error: %s' % error)
-      body.Append('Check server log for more details')
-      body.Append('</pre>')
-      raise
-
-  def _GetHighlighterParams(self, parsed_url):
-    """Get the highlighting parameters from a parsed url.
-    """
-    query_dict = urlparse.parse_qs(parsed_url.query)
-    return (query_dict.get('highlighter', ['pygments'])[0],
-        query_dict.get('style', ['colorful'])[0])
-
-  def _RenderNavPane(self, path):
-    """Renders an HTML nav pane.
-
-    This consists of a select element to set highlight style, and a list of all
-    files at |path| with the appropriate onclick handlers to open either
-    subdirectories or JSON files.
-    """
-    html = code.Code()
-
-    # Highlighter chooser.
-    html.Append('<select id="highlighters" onChange="updateEverything()">')
-    for name, highlighter in self.server.highlighters.items():
-      html.Append('<option value="%s">%s</option>' %
-          (name, highlighter.DisplayName()))
-    html.Append('</select>')
-
-    html.Append('<br/>')
-
-    # Style for each highlighter.
-    # The correct highlighting will be shown by Javascript.
-    for name, highlighter in self.server.highlighters.items():
-      styles = sorted(highlighter.GetStyles())
-      if not styles:
-        continue
-
-      html.Append('<select class="highlighter_styles" id="%s_styles" '
-                  'onChange="updateEverything()">' % name)
-      for style in styles:
-        html.Append('<option>%s</option>' % style)
-      html.Append('</select>')
-
-    html.Append('<br/>')
-
-    # The files, with appropriate handlers.
-    html.Append('<ul>')
-
-    # Make path point to a non-empty directory. This can happen if a URL like
-    # http://localhost:8000 is navigated to.
-    if path == '':
-      path = os.curdir
-
-    # Firstly, a .. link if this isn't the root.
-    if not os.path.samefile(os.curdir, path):
-      normpath = os.path.normpath(os.path.join(path, os.pardir))
-      html.Append('<li><a href="/%s">%s/</a>' % (normpath, os.pardir))
-
-    # Each file under path/
-    for filename in sorted(os.listdir(path)):
-      full_path = os.path.join(path, filename)
-      (file_root, file_ext) = os.path.splitext(full_path)
-      if os.path.isdir(full_path) and not full_path.endswith('.xcodeproj'):
-        html.Append('<li><a href="/%s/">%s/</a>' % (full_path, filename))
-      elif file_ext in ['.json', '.idl']:
-        # cc/h panes will automatically update via the hash change event.
-        html.Append('<li><a href="#%s">%s</a>' %
-            (filename, filename))
-
-    html.Append('</ul>')
-
-    return html.Render()
-
-
-class PreviewHTTPServer(HTTPServer, object):
-  def __init__(self,
-               server_address,
-               handler,
-               highlighters,
-               include_rules,
-               cpp_namespace_pattern):
-    super(PreviewHTTPServer, self).__init__(server_address, handler)
-    self.highlighters = highlighters
-    self.include_rules = include_rules
-    self.cpp_namespace_pattern = cpp_namespace_pattern
-
-
-if __name__ == '__main__':
-  parser = optparse.OptionParser(
-      description='Runs a server to preview the json_schema_compiler output.',
-      usage='usage: %prog [option]...')
-  parser.add_option('-p', '--port', default='8000',
-      help='port to run the server on')
-  parser.add_option('-n', '--namespace', default='generated_api_schemas',
-      help='C++ namespace for generated files. e.g extensions::api.')
-  parser.add_option('-I', '--include-rules',
-      help='A list of paths to include when searching for referenced objects,'
-      ' with the namespace separated by a \':\'. Example: '
-      '/foo/bar:Foo::Bar::%(namespace)s')
-
-  (opts, argv) = parser.parse_args()
-
-  def split_path_and_namespace(path_and_namespace):
-    if ':' not in path_and_namespace:
-      raise ValueError('Invalid include rule "%s". Rules must be of '
-                       'the form path:namespace' % path_and_namespace)
-    return path_and_namespace.split(':', 1)
-
-  include_rules = []
-  if opts.include_rules:
-    include_rules = map(split_path_and_namespace,
-                        shlex.split(opts.include_rules))
-
-  try:
-    print('Starting previewserver on port %s' % opts.port)
-    print('The extension documentation can be found at:')
-    print('')
-    print('  http://localhost:%s/chrome/common/extensions/api' % opts.port)
-    print('')
-
-    highlighters = {
-      'hilite': hilite_me_highlighter.HiliteMeHighlighter(),
-      'none': none_highlighter.NoneHighlighter()
-    }
-    try:
-      highlighters['pygments'] = pygments_highlighter.PygmentsHighlighter()
-    except ImportError as e:
-      pass
-
-    server = PreviewHTTPServer(('', int(opts.port)),
-                               CompilerHandler,
-                               highlighters,
-                               include_rules,
-                               opts.namespace)
-    server.serve_forever()
-  except KeyboardInterrupt:
-    server.socket.close()
diff --git a/tools/json_schema_compiler/schema_loader.py b/tools/json_schema_compiler/schema_loader.py
deleted file mode 100644
index b896991..0000000
--- a/tools/json_schema_compiler/schema_loader.py
+++ /dev/null
@@ -1,92 +0,0 @@
-# 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.
-
-import os
-import re
-import sys
-
-import idl_schema
-import json_schema
-from cpp_namespace_environment import CppNamespaceEnvironment
-from model import Model, UnixName
-
-def GenerateFilenames(full_namespace):
-  # Try to find the file defining the namespace. Eg. for
-  # nameSpace.sub_name_space.Type' the following heuristics looks for:
-  # 1. name_space_sub_name_space.json,
-  # 2. name_space_sub_name_space.idl,
-  # 3. sub_name_space.json,
-  # 4. sub_name_space.idl,
-  # 5. etc.
-  sub_namespaces = full_namespace.split('.')
-  filenames = [ ]
-  basename = None
-  for namespace in reversed(sub_namespaces):
-    if basename is not None:
-      basename = UnixName(namespace + '.' + basename)
-    else:
-      basename = UnixName(namespace)
-    for ext in ['json', 'idl']:
-      filenames.append('%s.%s' % (basename, ext))
-  return filenames
-
-class SchemaLoader(object):
-  '''Resolves a type name into the namespace the type belongs to.
-
-  Properties:
-  - |root| path to the root directory.
-  - |path| path to the directory with the API header files, relative to the
-    root.
-  - |include_rules| List containing tuples with (path, cpp_namespace_pattern)
-    used when searching for types.
-  - |cpp_namespace_pattern| Default namespace pattern
-  '''
-  def __init__(self,
-               root,
-               path,
-               include_rules,
-               cpp_namespace_pattern):
-    self._root = root
-    self._include_rules = [(path, cpp_namespace_pattern)]
-    self._include_rules.extend(include_rules)
-
-  def ResolveNamespace(self, full_namespace):
-    filenames = GenerateFilenames(full_namespace)
-    for path, cpp_namespace in self._include_rules:
-      for filename in reversed(filenames):
-        filepath = os.path.join(path, filename);
-        if os.path.exists(os.path.join(self._root, filepath)):
-          return Model().AddNamespace(
-              self.LoadSchema(filepath)[0],
-              filepath,
-              environment=CppNamespaceEnvironment(cpp_namespace))
-    return None
-
-  def ResolveType(self, full_name, default_namespace):
-    name_parts = full_name.rsplit('.', 1)
-    if len(name_parts) == 1:
-      if full_name not in default_namespace.types:
-        return None
-      return default_namespace
-    full_namespace, type_name = full_name.rsplit('.', 1)
-    namespace = self.ResolveNamespace(full_namespace)
-    if namespace and type_name in namespace.types:
-      return namespace
-    return None
-
-  def LoadSchema(self, schema):
-    '''Load a schema definition. The schema parameter must be a file name
-    with the full path relative to the root.'''
-    schema_filename, schema_extension = os.path.splitext(schema)
-
-    schema_path = os.path.join(self._root, schema)
-    if schema_extension == '.json':
-      api_defs = json_schema.Load(schema_path)
-    elif schema_extension == '.idl':
-      api_defs = idl_schema.Load(schema_path)
-    else:
-      sys.exit('Did not recognize file extension %s for schema %s' %
-               (schema_extension, schema))
-
-    return api_defs
diff --git a/tools/json_schema_compiler/schema_util.py b/tools/json_schema_compiler/schema_util.py
deleted file mode 100644
index b8fb404..0000000
--- a/tools/json_schema_compiler/schema_util.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# 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.
-"""Utilies for the processing of schema python structures.
-"""
-
-def CapitalizeFirstLetter(value):
-  return value[0].capitalize() + value[1:]
-
-
-def GetNamespace(ref):
-  return SplitNamespace(ref)[0]
-
-
-def StripNamespace(ref):
-  return SplitNamespace(ref)[1]
-
-
-def SplitNamespace(ref):
-  """Returns (namespace, entity) from |ref|, e.g. app.window.AppWindow ->
-  (app.window, AppWindow). If |ref| isn't qualified then returns (None, ref).
-  """
-  if '.' in ref:
-    return tuple(ref.rsplit('.', 1))
-  return (None, ref)
-
-
-def JsFunctionNameToClassName(namespace_name, function_name):
-  """Transform a fully qualified function name like foo.bar.baz into FooBarBaz
-
-  Also strips any leading 'Experimental' prefix."""
-  parts = []
-  full_name = namespace_name + "." + function_name
-  for part in full_name.split("."):
-    parts.append(CapitalizeFirstLetter(part))
-  if parts[0] == "Experimental":
-    del parts[0]
-  class_name = "".join(parts)
-  return class_name
diff --git a/tools/json_schema_compiler/schema_util_test.py b/tools/json_schema_compiler/schema_util_test.py
deleted file mode 100755
index 154da01..0000000
--- a/tools/json_schema_compiler/schema_util_test.py
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/usr/bin/env python
-# 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.
-
-from schema_util import JsFunctionNameToClassName
-from schema_util import StripNamespace
-import unittest
-
-class SchemaUtilTest(unittest.TestCase):
-  def testStripNamespace(self):
-    self.assertEquals('Bar', StripNamespace('foo.Bar'))
-    self.assertEquals('Baz', StripNamespace('Baz'))
-
-  def testJsFunctionNameToClassName(self):
-    self.assertEquals('FooBar', JsFunctionNameToClassName('foo', 'bar'))
-    self.assertEquals('FooBar',
-                      JsFunctionNameToClassName('experimental.foo', 'bar'))
-    self.assertEquals('FooBarBaz',
-                      JsFunctionNameToClassName('foo.bar', 'baz'))
-    self.assertEquals('FooBarBaz',
-                      JsFunctionNameToClassName('experimental.foo.bar', 'baz'))
-
-if __name__ == '__main__':
-  unittest.main()
diff --git a/tools/json_schema_compiler/test/additional_properties.json b/tools/json_schema_compiler/test/additional_properties.json
deleted file mode 100644
index a40c479..0000000
--- a/tools/json_schema_compiler/test/additional_properties.json
+++ /dev/null
@@ -1,56 +0,0 @@
-[
-  {
-    "namespace": "additionalProperties",
-    "description": "The additionalProperties API.",
-    "types": [
-      {
-        "id": "AdditionalPropertiesType",
-        "type": "object",
-        "properties": {
-          "string": {
-            "type": "string",
-            "description": "Some string."
-          }
-        },
-        "additionalProperties": { "type": "any" }
-      }
-    ],
-    "functions": [
-      {
-        "name": "additionalProperties",
-        "type": "function",
-        "description": "Takes an object with additionalProperties",
-        "parameters": [
-          {
-            "name": "paramObject",
-            "type": "object",
-            "properties": {},
-            "additionalProperties": {"type": "any"}
-          }
-        ]
-      },
-      {
-        "name": "returnAdditionalProperties",
-        "type": "function",
-        "description": "Returns an object with additionalProperties.",
-        "nodoc": "true",
-        "parameters": [
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "resultObject",
-                "type": "object",
-                "properties": {
-                  "integer": {"type": "integer"}
-                },
-                "additionalProperties": {"type": "string"}
-              }
-            ]
-          }
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/test/additional_properties_unittest.cc b/tools/json_schema_compiler/test/additional_properties_unittest.cc
deleted file mode 100644
index dc980af..0000000
--- a/tools/json_schema_compiler/test/additional_properties_unittest.cc
+++ /dev/null
@@ -1,64 +0,0 @@
-// 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.
-
-#include "testing/gtest/include/gtest/gtest.h"
-#include "tools/json_schema_compiler/test/additional_properties.h"
-
-using namespace test::api::additional_properties;
-
-TEST(JsonSchemaCompilerAdditionalPropertiesTest,
-    AdditionalPropertiesTypePopulate) {
-  {
-    scoped_ptr<base::ListValue> list_value(new base::ListValue());
-    list_value->Append(new base::StringValue("asdf"));
-    list_value->Append(new base::FundamentalValue(4));
-    scoped_ptr<base::DictionaryValue> type_value(new base::DictionaryValue());
-    type_value->SetString("string", "value");
-    type_value->SetInteger("other", 9);
-    type_value->Set("another", list_value.release());
-    scoped_ptr<AdditionalPropertiesType> type(new AdditionalPropertiesType());
-    ASSERT_TRUE(AdditionalPropertiesType::Populate(*type_value, type.get()));
-    EXPECT_TRUE(type->additional_properties.Equals(type_value.get()));
-  }
-  {
-    scoped_ptr<base::DictionaryValue> type_value(new base::DictionaryValue());
-    type_value->SetInteger("string", 3);
-    scoped_ptr<AdditionalPropertiesType> type(new AdditionalPropertiesType());
-    EXPECT_FALSE(AdditionalPropertiesType::Populate(*type_value, type.get()));
-  }
-}
-
-TEST(JsonSchemaCompilerAdditionalPropertiesTest,
-    AdditionalPropertiesParamsCreate) {
-  scoped_ptr<base::DictionaryValue> param_object_value(
-      new base::DictionaryValue());
-  param_object_value->SetString("str", "a");
-  param_object_value->SetInteger("num", 1);
-  scoped_ptr<base::ListValue> params_value(new base::ListValue());
-  params_value->Append(param_object_value->DeepCopy());
-  scoped_ptr<AdditionalProperties::Params> params(
-      AdditionalProperties::Params::Create(*params_value));
-  EXPECT_TRUE(params.get());
-  EXPECT_TRUE(params->param_object.additional_properties.Equals(
-      param_object_value.get()));
-}
-
-TEST(JsonSchemaCompilerAdditionalPropertiesTest,
-    ReturnAdditionalPropertiesResultCreate) {
-  ReturnAdditionalProperties::Results::ResultObject result_object;
-  result_object.integer = 5;
-  result_object.additional_properties["key"] = "value";
-
-  base::ListValue expected;
-  {
-    base::DictionaryValue* dict = new base::DictionaryValue();
-    dict->SetInteger("integer", 5);
-    dict->SetString("key", "value");
-    expected.Append(dict);
-  }
-
-  EXPECT_TRUE(base::Value::Equals(
-      ReturnAdditionalProperties::Results::Create(result_object).get(),
-      &expected));
-}
diff --git a/tools/json_schema_compiler/test/any.json b/tools/json_schema_compiler/test/any.json
deleted file mode 100644
index d836a04..0000000
--- a/tools/json_schema_compiler/test/any.json
+++ /dev/null
@@ -1,68 +0,0 @@
-[
-  {
-    "namespace": "any",
-    "description": "The any API.",
-    "types": [
-      {
-        "id": "AnyType",
-        "type": "object",
-        "properties": {
-          "any": {
-            "type": "any",
-            "description": "Any way you want it, that's the way you need it."
-          }
-        }
-      }
-    ],
-    "functions": [
-      {
-        "name": "optionalAny",
-        "type": "function",
-        "description": "Takes an optional any param.",
-        "parameters": [
-          {
-            "type": "any",
-            "name": "anyName",
-            "optional": true
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "returnAny",
-        "type": "function",
-        "description": "Returns any.",
-        "nodoc": "true",
-        "parameters": [
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "result",
-                "type": "any"
-              }
-            ]
-          }
-        ]
-      }
-    ],
-    "events": [
-      {
-        "name": "onAnyFired",
-        "type": "function",
-        "description": "Fired when anything is ready.",
-        "parameters": [
-          {
-            "name": "something",
-            "type": "any"
-          }
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/test/any_unittest.cc b/tools/json_schema_compiler/test/any_unittest.cc
deleted file mode 100644
index d10a3eb..0000000
--- a/tools/json_schema_compiler/test/any_unittest.cc
+++ /dev/null
@@ -1,59 +0,0 @@
-// 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.
-
-#include "testing/gtest/include/gtest/gtest.h"
-#include "tools/json_schema_compiler/test/any.h"
-
-using namespace test::api::any;
-
-TEST(JsonSchemaCompilerAnyTest, AnyTypePopulate) {
-  {
-    AnyType any_type;
-    scoped_ptr<base::DictionaryValue> any_type_value(
-        new base::DictionaryValue());
-    any_type_value->SetString("any", "value");
-    EXPECT_TRUE(AnyType::Populate(*any_type_value, &any_type));
-    scoped_ptr<base::Value> any_type_to_value(any_type.ToValue());
-    EXPECT_TRUE(any_type_value->Equals(any_type_to_value.get()));
-  }
-  {
-    AnyType any_type;
-    scoped_ptr<base::DictionaryValue> any_type_value(
-        new base::DictionaryValue());
-    any_type_value->SetInteger("any", 5);
-    EXPECT_TRUE(AnyType::Populate(*any_type_value, &any_type));
-    scoped_ptr<base::Value> any_type_to_value(any_type.ToValue());
-    EXPECT_TRUE(any_type_value->Equals(any_type_to_value.get()));
-  }
-}
-
-TEST(JsonSchemaCompilerAnyTest, OptionalAnyParamsCreate) {
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    scoped_ptr<OptionalAny::Params> params(
-        OptionalAny::Params::Create(*params_value));
-    EXPECT_TRUE(params.get());
-    EXPECT_FALSE(params->any_name.get());
-  }
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    scoped_ptr<base::Value> param(new base::StringValue("asdf"));
-    params_value->Append(param->DeepCopy());
-    scoped_ptr<OptionalAny::Params> params(
-        OptionalAny::Params::Create(*params_value));
-    ASSERT_TRUE(params);
-    ASSERT_TRUE(params->any_name);
-    EXPECT_TRUE(params->any_name->Equals(param.get()));
-  }
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    scoped_ptr<base::Value> param(new base::FundamentalValue(true));
-    params_value->Append(param->DeepCopy());
-    scoped_ptr<OptionalAny::Params> params(
-        OptionalAny::Params::Create(*params_value));
-    ASSERT_TRUE(params);
-    ASSERT_TRUE(params->any_name);
-    EXPECT_TRUE(params->any_name->Equals(param.get()));
-  }
-}
diff --git a/tools/json_schema_compiler/test/arrays.json b/tools/json_schema_compiler/test/arrays.json
deleted file mode 100644
index 23314e9..0000000
--- a/tools/json_schema_compiler/test/arrays.json
+++ /dev/null
@@ -1,274 +0,0 @@
-[
-  {
-    "namespace": "arrays",
-    "description": "The arrays API.",
-    "types": [
-      {
-        "id": "EnumArrayType",
-        "type": "object",
-        "properties": {
-          "types": {
-            "type": "array",
-            "items": {
-              "type": "string",
-              "enum": ["one", "two", "three"]
-            }
-          }
-        }
-      },
-      {
-        "id": "Enumeration",
-        "type": "string",
-        "enum": ["one", "two", "three"]
-      },
-      {
-        "id": "EnumArrayReference",
-        "type": "object",
-        "properties": {
-          "types": {
-            "type": "array",
-            "items": {
-              "$ref": "Enumeration"
-            }
-          }
-        }
-      },
-      {
-        "id": "EnumArrayMixed",
-        "type": "object",
-        "properties": {
-          "inline_enums": {
-            "type": "array",
-            "items": {
-              "type": "string",
-              "enum": ["one", "two", "three"]
-            }
-          },
-          "infile_enums": {
-            "type": "array",
-            "items": {
-              "$ref": "Enumeration"
-            }
-          },
-          "external_enums": {
-            "type": "array",
-            "items": {
-              "$ref": "enums.Enumeration"
-            }
-          }
-        }
-      },
-      {
-        "id": "OptionalEnumArrayType",
-        "type": "object",
-        "properties": {
-          "types": {
-            "type": "array",
-            "items": {
-              "type": "string",
-              "enum": ["one", "two", "three"]
-            },
-            "optional": true
-          }
-        }
-      },
-      {
-        "id": "BasicArrayType",
-        "type": "object",
-        "properties": {
-          "strings": {
-            "type": "array",
-            "items": {"type": "string"}
-          },
-          "booleans": {
-            "type": "array",
-            "items": {"type": "boolean"}
-          },
-          "numbers": {
-            "type": "array",
-            "items": {"type": "number"}
-          },
-          "integers": {
-            "type": "array",
-            "items": {"type": "integer"}
-          }
-        }
-      },
-      {
-        "id": "Item",
-        "type": "object",
-        "properties": {
-          "val": {
-            "type": "integer"
-          }
-        }
-      },
-      {
-        "id": "RefArrayType",
-        "type": "object",
-        "properties": {
-          "refs": {
-            "type": "array",
-            "items": { "$ref": "Item" }
-          }
-        }
-      }
-    ],
-    "functions": [
-      {
-        "name": "integerArray",
-        "type": "function",
-        "description": "Takes some integers.",
-        "parameters": [
-          {
-            "name": "nums",
-            "type": "array",
-            "items": {"type": "integer"}
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "anyArray",
-        "type": "function",
-        "description": "Takes some Items.",
-        "parameters": [
-          {
-            "name": "anys",
-            "type": "array",
-            "items": {"type": "any"}
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "objectArray",
-        "type": "function",
-        "description": "Takes some Items.",
-        "parameters": [
-          {
-            "name": "objects",
-            "type": "array",
-            "items": {
-              "type": "object",
-              "additionalProperties": {"type": "integer"}
-            }
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "refArray",
-        "type": "function",
-        "description": "Takes some Items.",
-        "parameters": [
-          {
-            "name": "refs",
-            "type": "array",
-            "items": {"$ref": "Item"}
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "justChoices",
-        "type": "function",
-        "description": "Takes some Choices.",
-        "parameters": [
-          {
-            "name": "choices",
-            "choices": [
-              { "type": "integer" },
-              { "type": "boolean" },
-              { "type": "array",
-                "items": {"$ref": "Item"}
-              }
-            ]
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "choicesArray",
-        "type": "function",
-        "description": "Takes some Choices.",
-        "parameters": [
-          {
-            "name": "choices",
-            "type": "array",
-            "items": {
-              "choices": [
-                { "type": "integer" },
-                { "type": "boolean" },
-                { "type": "array",
-                  "items": {"$ref": "Item"}
-                }
-              ]
-            }
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "returnIntegerArray",
-        "type": "function",
-        "description": "Returns some integers.",
-        "parameters": [
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-              {
-                "name": "integers",
-                "type": "array",
-                "items": {"type": "integer"}
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "returnRefArray",
-        "type": "function",
-        "description": "Returns some Items.",
-        "parameters": [
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-              {
-                "name": "refs",
-                "type": "array",
-                "items": {"$ref": "Item"}
-              }
-            ]
-          }
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/test/arrays_unittest.cc b/tools/json_schema_compiler/test/arrays_unittest.cc
deleted file mode 100644
index 79ebfb2..0000000
--- a/tools/json_schema_compiler/test/arrays_unittest.cc
+++ /dev/null
@@ -1,317 +0,0 @@
-// 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.
-
-#include "tools/json_schema_compiler/test/arrays.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-#include "tools/json_schema_compiler/test/enums.h"
-
-using namespace test::api::arrays;
-
-namespace {
-
-// TODO(calamity): Change to AppendString etc once kalman's patch goes through
-static scoped_ptr<base::DictionaryValue> CreateBasicArrayTypeDictionary() {
-  base::DictionaryValue* value = new base::DictionaryValue();
-  base::ListValue* strings_value = new base::ListValue();
-  strings_value->Append(new base::StringValue("a"));
-  strings_value->Append(new base::StringValue("b"));
-  strings_value->Append(new base::StringValue("c"));
-  strings_value->Append(new base::StringValue("it's easy as"));
-  base::ListValue* integers_value = new base::ListValue();
-  integers_value->Append(new base::FundamentalValue(1));
-  integers_value->Append(new base::FundamentalValue(2));
-  integers_value->Append(new base::FundamentalValue(3));
-  base::ListValue* booleans_value = new base::ListValue();
-  booleans_value->Append(new base::FundamentalValue(false));
-  booleans_value->Append(new base::FundamentalValue(true));
-  base::ListValue* numbers_value = new base::ListValue();
-  numbers_value->Append(new base::FundamentalValue(6.1));
-  value->Set("numbers", numbers_value);
-  value->Set("booleans", booleans_value);
-  value->Set("strings", strings_value);
-  value->Set("integers", integers_value);
-  return scoped_ptr<base::DictionaryValue>(value);
-}
-
-static base::Value* CreateItemValue(int val) {
-  base::DictionaryValue* value(new base::DictionaryValue());
-  value->Set("val", new base::FundamentalValue(val));
-  return value;
-}
-
-}  // namespace
-
-TEST(JsonSchemaCompilerArrayTest, BasicArrayType) {
-  {
-    scoped_ptr<base::DictionaryValue> value = CreateBasicArrayTypeDictionary();
-    scoped_ptr<BasicArrayType> basic_array_type(new BasicArrayType());
-    ASSERT_TRUE(BasicArrayType::Populate(*value, basic_array_type.get()));
-    EXPECT_TRUE(value->Equals(basic_array_type->ToValue().get()));
-  }
-}
-
-TEST(JsonSchemaCompilerArrayTest, EnumArrayType) {
-  // { "types": ["one", "two", "three"] }
-  base::ListValue* types = new base::ListValue();
-  types->AppendString("one");
-  types->AppendString("two");
-  types->AppendString("three");
-  base::DictionaryValue value;
-  value.Set("types", types);
-
-  EnumArrayType enum_array_type;
-
-  // Test Populate.
-  ASSERT_TRUE(EnumArrayType::Populate(value, &enum_array_type));
-  {
-    EnumArrayType::TypesType enums[] = {
-      EnumArrayType::TYPES_TYPE_ONE,
-      EnumArrayType::TYPES_TYPE_TWO,
-      EnumArrayType::TYPES_TYPE_THREE,
-    };
-    std::vector<EnumArrayType::TypesType> enums_vector(
-        enums, enums + arraysize(enums));
-    EXPECT_EQ(enums_vector, enum_array_type.types);
-  }
-
-  // Test ToValue.
-  scoped_ptr<base::Value> as_value(enum_array_type.ToValue());
-  EXPECT_TRUE(value.Equals(as_value.get())) << value << " != " << *as_value;
-}
-
-TEST(JsonSchemaCompilerArrayTest, EnumArrayReference) {
-  // { "types": ["one", "two", "three"] }
-  base::ListValue* types = new base::ListValue();
-  types->AppendString("one");
-  types->AppendString("two");
-  types->AppendString("three");
-  base::DictionaryValue value;
-  value.Set("types", types);
-
-  EnumArrayReference enum_array_reference;
-
-  // Test Populate.
-  ASSERT_TRUE(EnumArrayReference::Populate(value, &enum_array_reference));
-
-  Enumeration expected_types[] = {ENUMERATION_ONE, ENUMERATION_TWO,
-                                  ENUMERATION_THREE};
-  EXPECT_EQ(std::vector<Enumeration>(
-                expected_types, expected_types + arraysize(expected_types)),
-            enum_array_reference.types);
-
-  // Test ToValue.
-  scoped_ptr<base::Value> as_value(enum_array_reference.ToValue());
-  EXPECT_TRUE(value.Equals(as_value.get())) << value << " != " << *as_value;
-}
-
-TEST(JsonSchemaCompilerArrayTest, EnumArrayMixed) {
-  // { "types": ["one", "two", "three"] }
-  base::ListValue* inline_enums = new base::ListValue();
-  inline_enums->AppendString("one");
-  inline_enums->AppendString("two");
-  inline_enums->AppendString("three");
-
-  base::ListValue* infile_enums = new base::ListValue();
-  infile_enums->AppendString("one");
-  infile_enums->AppendString("two");
-  infile_enums->AppendString("three");
-
-  base::ListValue* external_enums = new base::ListValue();
-  external_enums->AppendString("one");
-  external_enums->AppendString("two");
-  external_enums->AppendString("three");
-
-  base::DictionaryValue value;
-  value.Set("inline_enums", inline_enums);
-  value.Set("infile_enums", infile_enums);
-  value.Set("external_enums", external_enums);
-
-  EnumArrayMixed enum_array_mixed;
-
-  // Test Populate.
-  ASSERT_TRUE(EnumArrayMixed::Populate(value, &enum_array_mixed));
-
-  EnumArrayMixed::Inline_enumsType expected_inline_types[] = {
-      EnumArrayMixed::INLINE_ENUMS_TYPE_ONE,
-      EnumArrayMixed::INLINE_ENUMS_TYPE_TWO,
-      EnumArrayMixed::INLINE_ENUMS_TYPE_THREE};
-  EXPECT_EQ(std::vector<EnumArrayMixed::Inline_enumsType>(
-                expected_inline_types,
-                expected_inline_types + arraysize(expected_inline_types)),
-            enum_array_mixed.inline_enums);
-
-  Enumeration expected_infile_types[] = {ENUMERATION_ONE, ENUMERATION_TWO,
-                                         ENUMERATION_THREE};
-  EXPECT_EQ(std::vector<Enumeration>(
-                expected_infile_types,
-                expected_infile_types + arraysize(expected_infile_types)),
-            enum_array_mixed.infile_enums);
-
-  test::api::enums::Enumeration expected_external_types[] = {
-      test::api::enums::ENUMERATION_ONE, test::api::enums::ENUMERATION_TWO,
-      test::api::enums::ENUMERATION_THREE};
-  EXPECT_EQ(std::vector<test::api::enums::Enumeration>(
-                expected_external_types,
-                expected_external_types + arraysize(expected_external_types)),
-            enum_array_mixed.external_enums);
-
-  // Test ToValue.
-  scoped_ptr<base::Value> as_value(enum_array_mixed.ToValue());
-  EXPECT_TRUE(value.Equals(as_value.get())) << value << " != " << *as_value;
-}
-
-TEST(JsonSchemaCompilerArrayTest, OptionalEnumArrayType) {
-  {
-    std::vector<OptionalEnumArrayType::TypesType> enums;
-    enums.push_back(OptionalEnumArrayType::TYPES_TYPE_ONE);
-    enums.push_back(OptionalEnumArrayType::TYPES_TYPE_TWO);
-    enums.push_back(OptionalEnumArrayType::TYPES_TYPE_THREE);
-
-    scoped_ptr<base::ListValue> types(new base::ListValue());
-    for (size_t i = 0; i < enums.size(); ++i) {
-      types->Append(new base::StringValue(
-          OptionalEnumArrayType::ToString(enums[i])));
-    }
-
-    base::DictionaryValue value;
-    value.Set("types", types.release());
-
-    OptionalEnumArrayType enum_array_type;
-    ASSERT_TRUE(OptionalEnumArrayType::Populate(value, &enum_array_type));
-    EXPECT_EQ(enums, *enum_array_type.types);
-  }
-  {
-    base::DictionaryValue value;
-    scoped_ptr<base::ListValue> enum_array(new base::ListValue());
-    enum_array->Append(new base::StringValue("invalid"));
-
-    value.Set("types", enum_array.release());
-    OptionalEnumArrayType enum_array_type;
-    ASSERT_FALSE(OptionalEnumArrayType::Populate(value, &enum_array_type));
-    EXPECT_TRUE(enum_array_type.types->empty());
-  }
-}
-
-TEST(JsonSchemaCompilerArrayTest, RefArrayType) {
-  {
-    scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-    scoped_ptr<base::ListValue> ref_array(new base::ListValue());
-    ref_array->Append(CreateItemValue(1));
-    ref_array->Append(CreateItemValue(2));
-    ref_array->Append(CreateItemValue(3));
-    value->Set("refs", ref_array.release());
-    scoped_ptr<RefArrayType> ref_array_type(new RefArrayType());
-    EXPECT_TRUE(RefArrayType::Populate(*value, ref_array_type.get()));
-    ASSERT_EQ(3u, ref_array_type->refs.size());
-    EXPECT_EQ(1, ref_array_type->refs[0]->val);
-    EXPECT_EQ(2, ref_array_type->refs[1]->val);
-    EXPECT_EQ(3, ref_array_type->refs[2]->val);
-  }
-  {
-    scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-    scoped_ptr<base::ListValue> not_ref_array(new base::ListValue());
-    not_ref_array->Append(CreateItemValue(1));
-    not_ref_array->Append(new base::FundamentalValue(3));
-    value->Set("refs", not_ref_array.release());
-    scoped_ptr<RefArrayType> ref_array_type(new RefArrayType());
-    EXPECT_FALSE(RefArrayType::Populate(*value, ref_array_type.get()));
-  }
-}
-
-TEST(JsonSchemaCompilerArrayTest, IntegerArrayParamsCreate) {
-  scoped_ptr<base::ListValue> params_value(new base::ListValue());
-  scoped_ptr<base::ListValue> integer_array(new base::ListValue());
-  integer_array->Append(new base::FundamentalValue(2));
-  integer_array->Append(new base::FundamentalValue(4));
-  integer_array->Append(new base::FundamentalValue(8));
-  params_value->Append(integer_array.release());
-  scoped_ptr<IntegerArray::Params> params(
-      IntegerArray::Params::Create(*params_value));
-  EXPECT_TRUE(params.get());
-  ASSERT_EQ(3u, params->nums.size());
-  EXPECT_EQ(2, params->nums[0]);
-  EXPECT_EQ(4, params->nums[1]);
-  EXPECT_EQ(8, params->nums[2]);
-}
-
-TEST(JsonSchemaCompilerArrayTest, AnyArrayParamsCreate) {
-  scoped_ptr<base::ListValue> params_value(new base::ListValue());
-  scoped_ptr<base::ListValue> any_array(new base::ListValue());
-  any_array->Append(new base::FundamentalValue(1));
-  any_array->Append(new base::StringValue("test"));
-  any_array->Append(CreateItemValue(2));
-  params_value->Append(any_array.release());
-  scoped_ptr<AnyArray::Params> params(
-      AnyArray::Params::Create(*params_value));
-  EXPECT_TRUE(params.get());
-  ASSERT_EQ(3u, params->anys.size());
-  int int_temp = 0;
-  EXPECT_TRUE(params->anys[0]->GetAsInteger(&int_temp));
-  EXPECT_EQ(1, int_temp);
-}
-
-TEST(JsonSchemaCompilerArrayTest, ObjectArrayParamsCreate) {
-  scoped_ptr<base::ListValue> params_value(new base::ListValue());
-  scoped_ptr<base::ListValue> item_array(new base::ListValue());
-  item_array->Append(CreateItemValue(1));
-  item_array->Append(CreateItemValue(2));
-  params_value->Append(item_array.release());
-  scoped_ptr<ObjectArray::Params> params(
-      ObjectArray::Params::Create(*params_value));
-  EXPECT_TRUE(params.get());
-  ASSERT_EQ(2u, params->objects.size());
-  EXPECT_EQ(1, params->objects[0]->additional_properties["val"]);
-  EXPECT_EQ(2, params->objects[1]->additional_properties["val"]);
-}
-
-TEST(JsonSchemaCompilerArrayTest, RefArrayParamsCreate) {
-  scoped_ptr<base::ListValue> params_value(new base::ListValue());
-  scoped_ptr<base::ListValue> item_array(new base::ListValue());
-  item_array->Append(CreateItemValue(1));
-  item_array->Append(CreateItemValue(2));
-  params_value->Append(item_array.release());
-  scoped_ptr<RefArray::Params> params(
-      RefArray::Params::Create(*params_value));
-  EXPECT_TRUE(params.get());
-  ASSERT_EQ(2u, params->refs.size());
-  EXPECT_EQ(1, params->refs[0]->val);
-  EXPECT_EQ(2, params->refs[1]->val);
-}
-
-TEST(JsonSchemaCompilerArrayTest, ReturnIntegerArrayResultCreate) {
-  std::vector<int> integers;
-  integers.push_back(1);
-  integers.push_back(2);
-  scoped_ptr<base::ListValue> results =
-      ReturnIntegerArray::Results::Create(integers);
-
-  base::ListValue expected;
-  base::ListValue* expected_argument = new base::ListValue();
-  expected_argument->Append(new base::FundamentalValue(1));
-  expected_argument->Append(new base::FundamentalValue(2));
-  expected.Append(expected_argument);
-  EXPECT_TRUE(results->Equals(&expected));
-}
-
-TEST(JsonSchemaCompilerArrayTest, ReturnRefArrayResultCreate) {
-  std::vector<linked_ptr<Item> > items;
-  items.push_back(linked_ptr<Item>(new Item()));
-  items.push_back(linked_ptr<Item>(new Item()));
-  items[0]->val = 1;
-  items[1]->val = 2;
-  scoped_ptr<base::ListValue> results =
-      ReturnRefArray::Results::Create(items);
-
-  base::ListValue expected;
-  base::ListValue* expected_argument = new base::ListValue();
-  base::DictionaryValue* first = new base::DictionaryValue();
-  first->SetInteger("val", 1);
-  expected_argument->Append(first);
-  base::DictionaryValue* second = new base::DictionaryValue();
-  second->SetInteger("val", 2);
-  expected_argument->Append(second);
-  expected.Append(expected_argument);
-  EXPECT_TRUE(results->Equals(&expected));
-}
diff --git a/tools/json_schema_compiler/test/browser_action.json b/tools/json_schema_compiler/test/browser_action.json
deleted file mode 100644
index 934d56d..0000000
--- a/tools/json_schema_compiler/test/browser_action.json
+++ /dev/null
@@ -1,273 +0,0 @@
-// 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.
-
-[
-  {
-    "namespace": "browserAction",
-    "description": "The browserAction API.",
-    "dependencies": [ "tabs" ],
-    "types": [
-      {
-        "id": "ColorArray",
-        "type": "array",
-        "items": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 255
-        },
-        "minItems": 4,
-        "maxItems": 4
-      }
-    ],
-    "functions": [
-      {
-        "name": "setTitle",
-        "type": "function",
-        "description": "Sets the title of the browser action. This shows up in the tooltip.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "title": {
-                "type": "string",
-                "description": "The string the browser action should display when moused over."
-              },
-              "tabId": {
-                "type": "integer",
-                "optional": true,
-                "description": "Limits the change to when a particular tab is selected. Automatically resets when the tab is closed."
-              }
-            }
-          }
-        ]
-      },
-      {
-        "name": "getTitle",
-        "type": "function",
-        "description": "Gets the title of the browser action.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "tabId": {
-                "type": "integer",
-                "optional": true,
-                "description": "Specify the tab to get the title from. If no tab is specified, the non-tab-specific title is returned."
-              }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "result",
-                "type": "string"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "setIcon",
-        "type": "function",
-        "description": "Sets the icon for the browser action. The icon can be specified either as the path to an image file or as the pixel data from a canvas element. Either the <b>path</b> or the <b>imageData</b> property must be specified.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "imageData": {
-                "type": "object",
-                "isInstanceOf": "ImageData",
-                "additionalProperties": { "type": "any" },
-                "description": "Pixel data for an image. Must be an ImageData object (for example, from a <code>canvas</code> element).",
-                "optional": true
-              },
-              "path": {
-                "type": "string",
-                "description": "Relative path to an image in the extension to show in the browser action.",
-                "optional": true
-              },
-              "tabId": {
-                "type": "integer",
-                "optional": true,
-                "description": "Limits the change to when a particular tab is selected. Automatically resets when the tab is closed."
-              }
-            }
-          }
-        ]
-      },
-      {
-        "name": "setPopup",
-        "type": "function",
-        "description": "Sets the html document to be opened as a popup when the user clicks on the browser action's icon.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "tabId": {
-                "type": "integer",
-                "optional": true,
-                "minimum": 0,
-                "description": "Limits the change to when a particular tab is selected. Automatically resets when the tab is closed."
-              },
-              "popup": {
-                "type": "string",
-                "description": "The html file to show in a popup.  If set to the empty string (''), no popup is shown."
-              }
-            }
-          }
-        ]
-      },
-      {
-        "name": "getPopup",
-        "type": "function",
-        "description": "Gets the html document set as the popup for this browser action.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "tabId": {
-                "type": "integer",
-                "optional": true,
-                "description": "Specify the tab to get the popup from. If no tab is specified, the non-tab-specific popup is returned."
-              }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "result",
-                "type": "string"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "setBadgeText",
-        "type": "function",
-        "description": "Sets the badge text for the browser action. The badge is displayed on top of the icon.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "text": {
-                "type": "string",
-                "description": "Any number of characters can be passed, but only about four can fit in the space."
-              },
-              "tabId": {
-                "type": "integer",
-                "optional": true,
-                "description": "Limits the change to when a particular tab is selected. Automatically resets when the tab is closed."
-              }
-            }
-          }
-        ]
-      },
-      {
-        "name": "getBadgeText",
-        "type": "function",
-        "description": "Gets the badge text of the browser action. If no tab is specified, the non-tab-specific badge text is returned.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "tabId": {
-                "type": "integer",
-                "optional": true,
-                "description": "Specify the tab to get the badge text from. If no tab is specified, the non-tab-specific badge text is returned."
-              }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "result",
-                "type": "string"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "setBadgeBackgroundColor",
-        "type": "function",
-        "description": "Sets the background color for the badge.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "color": {
-                "description": "An array of four integers in the range [0,255] that make up the RGBA color of the badge. For example, opaque red is <code>[255, 0, 0, 255]</code>. Can also be a string with a CSS value, with opaque red being <code>#FF0000</code> or <code>#F00</code>.",
-                "choices": [
-                  {"type": "string"},
-                  {"$ref": "ColorArray"}
-                ]
-              },
-              "tabId": {
-                "type": "integer",
-                "optional": true,
-                "description": "Limits the change to when a particular tab is selected. Automatically resets when the tab is closed."
-              }
-            }
-          }
-        ]
-      },
-      {
-        "name": "getBadgeBackgroundColor",
-        "type": "function",
-        "description": "Gets the background color of the browser action.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "tabId": {
-                "type": "integer",
-                "optional": true,
-                "description": "Specify the tab to get the badge background color from. If no tab is specified, the non-tab-specific badge background color is returned."
-              }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "result",
-                "$ref": "ColorArray"
-              }
-            ]
-          }
-        ]
-      }
-    ],
-    "events": [
-      {
-        "name": "onClicked",
-        "type": "function",
-        "description": "Fired when a browser action icon is clicked.  This event will not fire if the browser action has a popup.",
-        "parameters": [
-          {
-            "name": "tab",
-            "$ref": "Tab"
-          }
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/test/callbacks.json b/tools/json_schema_compiler/test/callbacks.json
deleted file mode 100644
index 2f86c26..0000000
--- a/tools/json_schema_compiler/test/callbacks.json
+++ /dev/null
@@ -1,72 +0,0 @@
-[
-  {
-    "namespace": "callbacks",
-    "description": "The callbacks API.",
-    "types": [],
-    "functions": [
-      {
-        "name": "returnsNothing",
-        "type": "function",
-        "description": "Takes nothing. Returns nothing.",
-        "parameters": [
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "returnsObject",
-        "description": "Returns an object.",
-        "type": "function",
-        "parameters": [
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-              {
-                "name": "someObject",
-                "type": "object",
-                "properties": {
-                  "state": {
-                    "type": "string",
-                    "enum": ["foo", "bar", "baz"]
-                  }
-                }
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "returnsMultiple",
-        "description": "Returns an object.",
-        "type": "function",
-        "parameters": [
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-              {
-                "name": "someInteger",
-                "type": "integer"
-              },
-              {
-                "name": "someObject",
-                "type": "object",
-                "properties": {
-                  "state": {
-                    "type": "string",
-                    "enum": ["foo", "bar", "baz"]
-                  }
-                }
-              }
-            ]
-          }
-        ]
-      }
-    ]
-  }
-]
-
diff --git a/tools/json_schema_compiler/test/callbacks_unittest.cc b/tools/json_schema_compiler/test/callbacks_unittest.cc
deleted file mode 100644
index 001e977..0000000
--- a/tools/json_schema_compiler/test/callbacks_unittest.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-// 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.
-
-#include "tools/json_schema_compiler/test/callbacks.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-using namespace test::api::callbacks;
-
-TEST(JsonSchemaCompilerCallbacksTest, ReturnsObjectResultCreate) {
-  ReturnsObject::Results::SomeObject some_object;
-  some_object.state = ReturnsObject::Results::SomeObject::STATE_FOO;
-  scoped_ptr<base::ListValue> results =
-      ReturnsObject::Results::Create(some_object);
-
-  base::DictionaryValue* expected_dict = new base::DictionaryValue();
-  expected_dict->SetString("state", "foo");
-  base::ListValue expected;
-  expected.Append(expected_dict);
-  EXPECT_TRUE(results->Equals(&expected));
-}
-
-TEST(JsonSchemaCompilerCallbacksTest, ReturnsMultipleResultCreate) {
-  ReturnsMultiple::Results::SomeObject some_object;
-  some_object.state = ReturnsMultiple::Results::SomeObject::STATE_FOO;
-  scoped_ptr<base::ListValue> results =
-      ReturnsMultiple::Results::Create(5, some_object);
-
-  base::DictionaryValue* expected_dict = new base::DictionaryValue();
-  expected_dict->SetString("state", "foo");
-  base::ListValue expected;
-  expected.Append(new base::FundamentalValue(5));
-  expected.Append(expected_dict);
-  EXPECT_TRUE(results->Equals(&expected));
-}
diff --git a/tools/json_schema_compiler/test/choices.json b/tools/json_schema_compiler/test/choices.json
deleted file mode 100644
index e7e39e0..0000000
--- a/tools/json_schema_compiler/test/choices.json
+++ /dev/null
@@ -1,167 +0,0 @@
-[
-  {
-    "namespace": "choices",
-    "description": "The choices API.",
-    "types": [
-      {
-        "id": "ChoiceType",
-        "type": "object",
-        "properties": {
-          "integers": {
-            "choices": [
-               {"type": "array", "items": {"type": "integer", "minimum": 0}},
-               {"type": "integer"}
-            ]
-          },
-          "strings": {
-            "choices": [
-               {"type": "array", "items": {"type": "string", "minimum": 0}},
-               {"type": "string"}
-            ],
-            "optional": true
-          }
-        }
-      },
-      {
-        "id": "NestedChoice",
-        "description": "Tests when some of the choices are choices themselves",
-        "choices": [
-          {"type": "integer"},
-          {"choices": [
-            {"type": "string"},
-            {"type": "boolean"}
-          ]},
-          {"choices": [
-            {"type": "double"},
-            {"$ref": "ChoiceType"},
-            {"type": "array", "items": {"$ref": "ChoiceType"}}
-          ]}
-        ]
-      }
-    ],
-    "functions": [
-      {
-        "name": "takesIntegers",
-        "type": "function",
-        "description": "Takes one or more integers.",
-        "parameters": [
-          {
-            "name": "nums",
-            "choices": [
-               {"type": "array", "items": {"type": "integer", "minimum": 0}},
-               {"type": "integer"}
-             ]
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "takesIntegersOptional",
-        "type": "function",
-        "description": "Takes one or more integers.",
-        "parameters": [
-          {
-            "name": "nums",
-            "choices": [
-               {"type": "array", "items": {"type": "integer", "minimum": 0}},
-               {"type": "integer"}
-            ],
-            "optional": true
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "objectWithChoices",
-        "type": "function",
-        "description": "Takes an object with one or more strings and optional integer(s).",
-        "parameters": [
-          {
-            "type": "object",
-            "name": "stringInfo",
-            "properties": {
-               "strings": {
-                 "description": "One or more tab indices to highlight.",
-                 "choices": [
-                   {"type": "array", "items": {"type": "string", "minimum": 0}},
-                   {"type": "string"}
-                 ]
-               },
-               "integers": {
-                 "description": "One or more tab indices to highlight.",
-                 "choices": [
-                   {"type": "array", "items": {"type": "integer", "minimum": 0}},
-                   {"type": "integer"}
-                 ],
-                 "optional": true
-               }
-             }
-           },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "returnChoices",
-        "type": "function",
-        "description": "Gives back a string. Or not.",
-        "parameters": [
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-              {
-                "name": "result",
-                "choices": [
-                   {"type": "array", "items": {"type": "integer", "minimum": 0}},
-                   {"type": "integer"}
-                 ],
-                "description": "Some integers."
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "returnMultipleChoices",
-        "type": "function",
-        "description": "Gives back two values where each is an integer or a list of integers.",
-        "parameters": [
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-              {
-                "name": "firstResult",
-                "choices": [
-                   {"type": "array", "items": {"type": "integer", "minimum": 0}},
-                   {"type": "integer"}
-                 ],
-                "description": "Some integers."
-              },
-              {
-                "name": "secondResult",
-                "choices": [
-                   {"type": "array", "items": {"type": "integer", "minimum": 0}},
-                   {"type": "integer"}
-                 ],
-                "description": "Some integers."
-              }
-            ]
-          }
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/test/choices_unittest.cc b/tools/json_schema_compiler/test/choices_unittest.cc
deleted file mode 100644
index 2cf1d8d..0000000
--- a/tools/json_schema_compiler/test/choices_unittest.cc
+++ /dev/null
@@ -1,292 +0,0 @@
-// 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.
-
-#include "tools/json_schema_compiler/test/choices.h"
-
-#include "base/strings/string_piece.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "tools/json_schema_compiler/test/test_util.h"
-
-namespace {
-
-using namespace test::api::choices;
-using json_schema_compiler::test_util::Dictionary;
-using json_schema_compiler::test_util::List;
-using json_schema_compiler::test_util::ReadJson;
-using json_schema_compiler::test_util::Vector;
-
-TEST(JsonSchemaCompilerChoicesTest, TakesIntegersParamsCreate) {
-  {
-    scoped_ptr<TakesIntegers::Params> params(
-        TakesIntegers::Params::Create(*List(new base::FundamentalValue(true))));
-    EXPECT_FALSE(params);
-  }
-  {
-    scoped_ptr<TakesIntegers::Params> params(
-        TakesIntegers::Params::Create(*List(new base::FundamentalValue(6))));
-    ASSERT_TRUE(params);
-    EXPECT_FALSE(params->nums.as_integers);
-    EXPECT_EQ(6, *params->nums.as_integer);
-  }
-  {
-    scoped_ptr<TakesIntegers::Params> params(TakesIntegers::Params::Create(
-        *List(List(new base::FundamentalValue(2),
-                   new base::FundamentalValue(6),
-                   new base::FundamentalValue(8)).release())));
-    ASSERT_TRUE(params);
-    ASSERT_TRUE(params->nums.as_integers);
-    EXPECT_EQ(Vector(2, 6, 8), *params->nums.as_integers);
-  }
-}
-
-TEST(JsonSchemaCompilerChoicesTest, ObjectWithChoicesParamsCreate) {
-  {
-    scoped_ptr<ObjectWithChoices::Params> params(
-        ObjectWithChoices::Params::Create(*List(
-            Dictionary("strings", new base::StringValue("asdf")).release())));
-    ASSERT_TRUE(params);
-    EXPECT_FALSE(params->string_info.strings.as_strings);
-    EXPECT_EQ("asdf", *params->string_info.strings.as_string);
-    EXPECT_FALSE(params->string_info.integers);
-  }
-  {
-    scoped_ptr<ObjectWithChoices::Params> params(
-        ObjectWithChoices::Params::Create(*List(
-            Dictionary("strings", new base::StringValue("asdf"),
-                       "integers", new base::FundamentalValue(6)).release())));
-    ASSERT_TRUE(params);
-    EXPECT_FALSE(params->string_info.strings.as_strings);
-    EXPECT_EQ("asdf", *params->string_info.strings.as_string);
-    ASSERT_TRUE(params->string_info.integers);
-    EXPECT_FALSE(params->string_info.integers->as_integers);
-    EXPECT_EQ(6, *params->string_info.integers->as_integer);
-  }
-}
-
-// TODO(kalman): Clean up the rest of these tests to use the
-// Vector/List/Dictionary helpers.
-
-TEST(JsonSchemaCompilerChoicesTest, ObjectWithChoicesParamsCreateFail) {
-  {
-    scoped_ptr<base::DictionaryValue> object_param(new base::DictionaryValue());
-    object_param->SetWithoutPathExpansion("strings",
-                                          new base::FundamentalValue(5));
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    params_value->Append(object_param.release());
-    scoped_ptr<ObjectWithChoices::Params> params(
-        ObjectWithChoices::Params::Create(*params_value));
-    EXPECT_FALSE(params.get());
-  }
-  {
-    scoped_ptr<base::DictionaryValue> object_param(new base::DictionaryValue());
-    object_param->SetWithoutPathExpansion("strings",
-                                          new base::StringValue("asdf"));
-    object_param->SetWithoutPathExpansion("integers",
-                                          new base::StringValue("asdf"));
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    params_value->Append(object_param.release());
-    scoped_ptr<ObjectWithChoices::Params> params(
-        ObjectWithChoices::Params::Create(*params_value));
-    EXPECT_FALSE(params.get());
-  }
-  {
-    scoped_ptr<base::DictionaryValue> object_param(new base::DictionaryValue());
-    object_param->SetWithoutPathExpansion("integers",
-                                          new base::FundamentalValue(6));
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    params_value->Append(object_param.release());
-    scoped_ptr<ObjectWithChoices::Params> params(
-        ObjectWithChoices::Params::Create(*params_value));
-    EXPECT_FALSE(params.get());
-  }
-}
-
-TEST(JsonSchemaCompilerChoicesTest, PopulateChoiceType) {
-  std::vector<std::string> strings = Vector(std::string("list"),
-                                            std::string("of"),
-                                            std::string("strings"));
-
-  base::ListValue* strings_value = new base::ListValue();
-  for (size_t i = 0; i < strings.size(); ++i)
-    strings_value->Append(new base::StringValue(strings[i]));
-
-  base::DictionaryValue value;
-  value.SetInteger("integers", 4);
-  value.Set("strings", strings_value);
-
-  ChoiceType out;
-  ASSERT_TRUE(ChoiceType::Populate(value, &out));
-  ASSERT_TRUE(out.integers.as_integer.get());
-  EXPECT_FALSE(out.integers.as_integers.get());
-  EXPECT_EQ(4, *out.integers.as_integer);
-
-  EXPECT_FALSE(out.strings->as_string.get());
-  ASSERT_TRUE(out.strings->as_strings.get());
-  EXPECT_EQ(strings, *out.strings->as_strings);
-}
-
-TEST(JsonSchemaCompilerChoicesTest, ChoiceTypeToValue) {
-  base::ListValue* strings_value = new base::ListValue();
-  strings_value->Append(new base::StringValue("list"));
-  strings_value->Append(new base::StringValue("of"));
-  strings_value->Append(new base::StringValue("strings"));
-
-  base::DictionaryValue value;
-  value.SetInteger("integers", 5);
-  value.Set("strings", strings_value);
-
-  ChoiceType out;
-  ASSERT_TRUE(ChoiceType::Populate(value, &out));
-
-  EXPECT_TRUE(value.Equals(out.ToValue().get()));
-}
-
-TEST(JsonSchemaCompilerChoicesTest, ReturnChoices) {
-  {
-    ReturnChoices::Results::Result results;
-    results.as_integers.reset(new std::vector<int>(Vector(1, 2)));
-
-    scoped_ptr<base::Value> results_value = results.ToValue();
-    ASSERT_TRUE(results_value);
-
-    base::ListValue expected;
-    expected.AppendInteger(1);
-    expected.AppendInteger(2);
-
-    EXPECT_TRUE(expected.Equals(results_value.get()));
-  }
-  {
-    ReturnChoices::Results::Result results;
-    results.as_integer.reset(new int(5));
-
-    scoped_ptr<base::Value> results_value = results.ToValue();
-    ASSERT_TRUE(results_value);
-
-    base::FundamentalValue expected(5);
-
-    EXPECT_TRUE(expected.Equals(results_value.get()));
-  }
-}
-
-TEST(JsonSchemaCompilerChoicesTest, NestedChoices) {
-  // These test both ToValue and FromValue for every legitimate configuration of
-  // NestedChoices.
-  {
-    // The plain integer choice.
-    scoped_ptr<base::Value> value = ReadJson("42");
-    scoped_ptr<NestedChoice> obj = NestedChoice::FromValue(*value);
-
-    ASSERT_TRUE(obj);
-    ASSERT_TRUE(obj->as_integer);
-    EXPECT_FALSE(obj->as_choice1);
-    EXPECT_FALSE(obj->as_choice2);
-    EXPECT_EQ(42, *obj->as_integer);
-
-    EXPECT_TRUE(base::Value::Equals(value.get(), obj->ToValue().get()));
-  }
-
-  {
-    // The string choice within the first choice.
-    scoped_ptr<base::Value> value = ReadJson("\"foo\"");
-    scoped_ptr<NestedChoice> obj = NestedChoice::FromValue(*value);
-
-    ASSERT_TRUE(obj);
-    EXPECT_FALSE(obj->as_integer);
-    ASSERT_TRUE(obj->as_choice1);
-    EXPECT_FALSE(obj->as_choice2);
-    ASSERT_TRUE(obj->as_choice1->as_string);
-    EXPECT_FALSE(obj->as_choice1->as_boolean);
-    EXPECT_EQ("foo", *obj->as_choice1->as_string);
-
-    EXPECT_TRUE(base::Value::Equals(value.get(), obj->ToValue().get()));
-  }
-
-  {
-    // The boolean choice within the first choice.
-    scoped_ptr<base::Value> value = ReadJson("true");
-    scoped_ptr<NestedChoice> obj = NestedChoice::FromValue(*value);
-
-    ASSERT_TRUE(obj);
-    EXPECT_FALSE(obj->as_integer);
-    ASSERT_TRUE(obj->as_choice1);
-    EXPECT_FALSE(obj->as_choice2);
-    EXPECT_FALSE(obj->as_choice1->as_string);
-    ASSERT_TRUE(obj->as_choice1->as_boolean);
-    EXPECT_TRUE(*obj->as_choice1->as_boolean);
-
-    EXPECT_TRUE(base::Value::Equals(value.get(), obj->ToValue().get()));
-  }
-
-  {
-    // The double choice within the second choice.
-    scoped_ptr<base::Value> value = ReadJson("42.0");
-    scoped_ptr<NestedChoice> obj = NestedChoice::FromValue(*value);
-
-    ASSERT_TRUE(obj);
-    EXPECT_FALSE(obj->as_integer);
-    EXPECT_FALSE(obj->as_choice1);
-    ASSERT_TRUE(obj->as_choice2);
-    ASSERT_TRUE(obj->as_choice2->as_double);
-    EXPECT_FALSE(obj->as_choice2->as_choice_type);
-    EXPECT_FALSE(obj->as_choice2->as_choice_types);
-    EXPECT_EQ(42.0, *obj->as_choice2->as_double);
-
-    EXPECT_TRUE(base::Value::Equals(value.get(), obj->ToValue().get()));
-  }
-
-  {
-    // The ChoiceType choice within the second choice.
-    scoped_ptr<base::Value> value = ReadJson(
-        "{\"integers\": [1, 2], \"strings\": \"foo\"}");
-    scoped_ptr<NestedChoice> obj = NestedChoice::FromValue(*value);
-
-    ASSERT_TRUE(obj);
-    EXPECT_FALSE(obj->as_integer);
-    EXPECT_FALSE(obj->as_choice1);
-    ASSERT_TRUE(obj->as_choice2);
-    EXPECT_FALSE(obj->as_choice2->as_double);
-    ASSERT_TRUE(obj->as_choice2->as_choice_type);
-    EXPECT_FALSE(obj->as_choice2->as_choice_types);
-    {
-      ChoiceType* choice_type = obj->as_choice2->as_choice_type.get();
-      ASSERT_TRUE(choice_type->integers.as_integers);
-      EXPECT_FALSE(choice_type->integers.as_integer);
-      EXPECT_EQ(Vector(1, 2), *choice_type->integers.as_integers);
-      ASSERT_TRUE(choice_type->strings);
-      EXPECT_FALSE(choice_type->strings->as_strings);
-      ASSERT_TRUE(choice_type->strings->as_string);
-      EXPECT_EQ("foo", *choice_type->strings->as_string);
-    }
-
-    EXPECT_TRUE(base::Value::Equals(value.get(), obj->ToValue().get()));
-  }
-
-  {
-    // The array of ChoiceTypes within the second choice.
-    scoped_ptr<base::Value> value = ReadJson(
-        "["
-        "  {\"integers\": [1, 2], \"strings\": \"foo\"},"
-        "  {\"integers\": 3, \"strings\": [\"bar\", \"baz\"]}"
-        "]");
-    scoped_ptr<NestedChoice> obj = NestedChoice::FromValue(*value);
-
-    ASSERT_TRUE(obj);
-    EXPECT_FALSE(obj->as_integer);
-    EXPECT_FALSE(obj->as_choice1);
-    ASSERT_TRUE(obj->as_choice2);
-    EXPECT_FALSE(obj->as_choice2->as_double);
-    EXPECT_FALSE(obj->as_choice2->as_choice_type);
-    ASSERT_TRUE(obj->as_choice2->as_choice_types);
-    {
-      std::vector<linked_ptr<ChoiceType> >* choice_types =
-          obj->as_choice2->as_choice_types.get();
-      // Bleh too much effort to test everything.
-      ASSERT_EQ(2u, choice_types->size());
-    }
-
-    EXPECT_TRUE(base::Value::Equals(value.get(), obj->ToValue().get()));
-  }
-}
-
-}  // namespace
diff --git a/tools/json_schema_compiler/test/content_settings.json b/tools/json_schema_compiler/test/content_settings.json
deleted file mode 100644
index 6fac436..0000000
--- a/tools/json_schema_compiler/test/content_settings.json
+++ /dev/null
@@ -1,222 +0,0 @@
-// 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.
-
-[
-  {
-    "namespace": "contentSettings",
-    "description": "The contentSettings API.",
-    "types": [
-      {
-        "id": "ResourceIdentifier",
-        "type": "object",
-        "properties": {
-          "id": {
-            "type": "string",
-            "description": "The resource identifier for the given content type."
-          },
-          "description": {
-            "type": "string",
-            "optional": true,
-            "description": "A human readable description of the resource."
-          }
-        },
-        "description": "The only content type using resource identifiers is <a href=\"contentSettings.html#property-plugins\"><var>plugins</var></a>. For more information, see <a href=\"contentSettings.html#resource-identifiers\">Resource Identifiers</a>."
-      },
-      {
-        "id": "ContentSetting",
-        "type": "object",
-        "functions": [
-          {
-            "name": "clear",
-            "type": "function",
-            "description": "Clear all content setting rules set by this extension.",
-            "parameters": [
-              {
-                "name": "details",
-                "type": "object",
-                "properties": {
-                  "scope": {
-                    "type": "string",
-                    "enum": ["regular", "incognito_session_only"],
-                    "optional": true,
-                    "description": "Where to set the setting (default: regular). One of<br><var>regular</var>: setting for regular profile (which is inherited by the incognito profile if not overridden elsewhere),<br><var>incognito_session_only</var>: setting for incognito profile that can only be set during an incognito session and is deleted when the incognito session ends (overrides regular settings)."
-                  }
-                }
-              },
-              {
-                "type": "function",
-                "name": "callback",
-                "optional": true,
-                "parameters": []
-              }
-            ]
-          },
-          {
-            "name": "get",
-            "type": "function",
-            "description": "Gets the current content setting for a given pair of URLs.",
-            "parameters": [
-              {
-                "name": "details",
-                "type": "object",
-                "properties": {
-                  "primaryUrl": {
-                    "type": "string",
-                    "description": "The primary URL for which the content setting should be retrieved. Note that the meaning of a primary URL depends on the content type."
-                  },
-                  "secondaryUrl": {
-                    "type": "string",
-                    "description": "The secondary URL for which the content setting should be retrieved. Defaults to the primary URL. Note that the meaning of a secondary URL depends on the content type, and not all content types use secondary URLs.",
-                    "optional": true
-                  },
-                  "resourceIdentifier": {
-                    "$ref": "ResourceIdentifier",
-                    "optional": true,
-                    "description": "A more specific identifier of the type of content for which the settings should be retrieved."
-                  },
-                  "incognito": {
-                    "type": "boolean",
-                    "optional": true,
-                    "description": "Whether to check the content settings for an incognito session. (default false)"
-                  }
-                }
-              },
-              {
-                "type": "function",
-                "name": "callback",
-                "parameters": [
-                  {
-                    "name": "details",
-                    "type": "object",
-                    "properties": {
-                      "setting": {
-                        "type": "any",
-                        "description": "The content setting. See the description of the individual ContentSetting objects for the possible values."
-                      }
-                    }
-                  }
-                ]
-              }
-            ]
-          },
-          {
-            "name": "set",
-            "type": "function",
-            "description": "Applies a new content setting rule.",
-            "parameters": [
-              {
-                "name": "details",
-                "type": "object",
-                "properties": {
-                  "primaryPattern": {
-                    "type": "string",
-                    "description": "The pattern for the primary URL. For details on the format of a pattern, see <a href='contentSettings.html#patterns'>Content Setting Patterns</a>."
-                  },
-                  "secondaryPattern": {
-                    "type": "string",
-                    "description": "The pattern for the secondary URL. Defaults to matching all URLs. For details on the format of a pattern, see <a href='contentSettings.html#patterns'>Content Setting Patterns</a>.",
-                    "optional": true
-                  },
-                  "resourceIdentifier": {
-                    "$ref": "ResourceIdentifier",
-                    "optional": true,
-                    "description": "The resource identifier for the content type."
-                  },
-                  "setting": {
-                    "type": "any",
-                    "description": "The setting applied by this rule. See the description of the individual ContentSetting objects for the possible values."
-                  },
-                  "scope": {
-                    "type": "string",
-                    "enum": ["regular", "incognito_session_only"],
-                    "optional": true,
-                    "description": "Where to clear the setting (default: regular). One of<br><var>regular</var>: setting for regular profile (which is inherited by the incognito profile if not overridden elsewhere),<br><var>incognito_session_only</var>: setting for incognito profile that can only be set during an incognito session and is deleted when the incognito session ends (overrides regular settings)."
-                  }
-                }
-              },
-              {
-                "type": "function",
-                "name": "callback",
-                "optional": true,
-                "parameters": []
-              }
-            ]
-          },
-          {
-            "name": "getResourceIdentifiers",
-            "type": "function",
-            "description": "",
-            "parameters": [
-              {
-                "name": "callback",
-                "type": "function",
-                "parameters": [
-                  {
-                    "name": "resourceIdentifiers",
-                    "type": "array",
-                    "description": "A list of resource identifiers for this content type, or <var>undefined</var> if this content type does not use resource identifiers.",
-                    "optional": true,
-                    "items": {
-                      "$ref": "ResourceIdentifier"
-                    }
-                  }
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    ],
-    "properties": {
-      "cookies": {
-        "$ref": "ContentSetting",
-        "description": "Whether to allow cookies and other local data to be set by websites. One of<br><var>allow</var>: Accept cookies,<br><var>block</var>: Block cookies,<br><var>session_only</var>: Accept cookies only for the current session. <br>Default is <var>allow</var>.<br>The primary URL is the URL representing the cookie origin. The secondary URL is the URL of the top-level frame.",
-        "value": [
-          "cookies",
-          {"type":"string", "enum": ["allow", "block", "session_only"]}
-        ]
-      },
-      "images": {
-        "$ref": "ContentSetting",
-        "description": "Whether to show images. One of<br><var>allow</var>: Show images,<br><var>block</var>: Don't show images. <br>Default is <var>allow</var>.<br>The primary URL is the main-frame URL. The secondary URL is the URL of the image.",
-        "value": [
-          "images",
-          {"type":"string", "enum": ["allow", "block"]}
-        ]
-      },
-      "javascript": {
-        "$ref": "ContentSetting",
-        "description": "Whether to run JavaScript. One of<br><var>allow</var>: Run JavaScript,<br><var>block</var>: Don't run JavaScript. <br>Default is <var>allow</var>.<br>The primary URL is the main-frame URL. The secondary URL is not used.",
-        "value": [
-          "javascript",
-          {"type":"string", "enum": ["allow", "block"]}
-        ]
-      },
-      "plugins": {
-        "$ref": "ContentSetting",
-        "description": "Whether to run plug-ins. One of<br><var>allow</var>: Run plug-ins automatically,<br><var>block</var>: Don't run plug-ins automatically. <br>Default is <var>allow</var>.<br>The primary URL is the main-frame URL. The secondary URL is not used.",
-        "value": [
-          "plugins",
-          {"type":"string", "enum": ["allow", "block"]}
-        ]
-      },
-      "popups": {
-        "$ref": "ContentSetting",
-        "description": "Whether to allow sites to show pop-ups. One of<br><var>allow</var>: Allow sites to show pop-ups,<br><var>block</var>: Don't allow sites to show pop-ups. <br>Default is <var>block</var>.<br>The primary URL is the main-frame URL. The secondary URL is not used.",
-        "value": [
-          "popups",
-          {"type":"string", "enum": ["allow", "block"]}
-        ]
-      },
-      "notifications": {
-        "$ref": "ContentSetting",
-        "description": "Whether to allow sites to show desktop notifications. One of<br><var>allow</var>: Allow sites to show desktop notifications,<br><var>block</var>: Don't allow sites to show desktop notifications,<br><var>ask</var>: Ask when a site wants to show desktop notifications. <br>Default is <var>ask</var>.<br>The primary URL is the main-frame URL. The secondary URL is not used.",
-        "value": [
-          "notifications",
-          {"type":"string", "enum": ["allow", "block", "ask"]}
-        ]
-      }
-    }
-  }
-]
diff --git a/tools/json_schema_compiler/test/crossref.json b/tools/json_schema_compiler/test/crossref.json
deleted file mode 100644
index a1e994b..0000000
--- a/tools/json_schema_compiler/test/crossref.json
+++ /dev/null
@@ -1,76 +0,0 @@
-[
-  {
-    "namespace": "crossref",
-    "description": "The crossref API.",
-    "dependencies": ["simple_api"],
-    "types": [
-      {
-        "id": "CrossrefType",
-        "type": "object",
-        "properties": {
-          "testType": {
-            "$ref": "simple_api.TestType",
-            "optional": true
-          }
-        }
-      }
-    ],
-    "functions": [
-      {
-        "name": "testTypeOptionalParam",
-        "type": "function",
-        "description": "Takes TestType as a param.",
-        "parameters": [
-          {
-            "name": "testType",
-            "$ref": "simple_api.TestType",
-            "optional": true
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "getTestType",
-        "type": "function",
-        "description": "Return a TestType.",
-        "parameters": [
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-              {
-                "name": "result",
-                "$ref": "simple_api.TestType",
-                "description": "A TestType."
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "testTypeInObject",
-        "type": "function",
-        "description": "Takes an optional object with a TestType and a bool.",
-        "parameters": [
-          {
-            "name": "paramObject",
-            "type": "object",
-            "properties": {
-              "testType": {"$ref": "simple_api.TestType", "optional": true},
-              "boolean": {"type": "boolean"}
-            }
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/test/crossref_unittest.cc b/tools/json_schema_compiler/test/crossref_unittest.cc
deleted file mode 100644
index 7d8879d..0000000
--- a/tools/json_schema_compiler/test/crossref_unittest.cc
+++ /dev/null
@@ -1,121 +0,0 @@
-// 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.
-
-#include "tools/json_schema_compiler/test/simple_api.h"
-#include "tools/json_schema_compiler/test/crossref.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-using namespace test::api::crossref;
-
-namespace {
-
-static scoped_ptr<base::DictionaryValue> CreateTestTypeDictionary() {
-  base::DictionaryValue* value(new base::DictionaryValue());
-  value->SetWithoutPathExpansion("number", new base::FundamentalValue(1.1));
-  value->SetWithoutPathExpansion("integer", new base::FundamentalValue(4));
-  value->SetWithoutPathExpansion("string", new base::StringValue("bling"));
-  value->SetWithoutPathExpansion("boolean", new base::FundamentalValue(true));
-  return scoped_ptr<base::DictionaryValue>(value);
-}
-
-}  // namespace
-
-TEST(JsonSchemaCompilerCrossrefTest, CrossrefTypePopulate) {
-  scoped_ptr<CrossrefType> crossref_type(new CrossrefType());
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  value->Set("testType", CreateTestTypeDictionary().release());
-  EXPECT_TRUE(CrossrefType::Populate(*value, crossref_type.get()));
-  EXPECT_TRUE(crossref_type->test_type.get());
-  EXPECT_TRUE(CreateTestTypeDictionary()->Equals(
-        crossref_type->test_type->ToValue().get()));
-  EXPECT_TRUE(value->Equals(crossref_type->ToValue().get()));
-}
-
-TEST(JsonSchemaCompilerCrossrefTest, TestTypeOptionalParamCreate) {
-  scoped_ptr<base::ListValue> params_value(new base::ListValue());
-  params_value->Append(CreateTestTypeDictionary().release());
-  scoped_ptr<TestTypeOptionalParam::Params> params(
-      TestTypeOptionalParam::Params::Create(*params_value));
-  EXPECT_TRUE(params.get());
-  EXPECT_TRUE(params->test_type.get());
-  EXPECT_TRUE(
-      CreateTestTypeDictionary()->Equals(params->test_type->ToValue().get()));
-}
-
-TEST(JsonSchemaCompilerCrossrefTest, TestTypeOptionalParamFail) {
-  scoped_ptr<base::ListValue> params_value(new base::ListValue());
-  scoped_ptr<base::DictionaryValue> test_type_value =
-      CreateTestTypeDictionary();
-  test_type_value->RemoveWithoutPathExpansion("number", NULL);
-  params_value->Append(test_type_value.release());
-  scoped_ptr<TestTypeOptionalParam::Params> params(
-      TestTypeOptionalParam::Params::Create(*params_value));
-  EXPECT_FALSE(params.get());
-}
-
-TEST(JsonSchemaCompilerCrossrefTest, GetTestType) {
-  scoped_ptr<base::DictionaryValue> value = CreateTestTypeDictionary();
-  scoped_ptr<test::api::simple_api::TestType> test_type(
-      new test::api::simple_api::TestType());
-  EXPECT_TRUE(
-      test::api::simple_api::TestType::Populate(*value, test_type.get()));
-
-  scoped_ptr<base::ListValue> results =
-      GetTestType::Results::Create(*test_type);
-  base::DictionaryValue* result_dict = NULL;
-  results->GetDictionary(0, &result_dict);
-  EXPECT_TRUE(value->Equals(result_dict));
-}
-
-TEST(JsonSchemaCompilerCrossrefTest, TestTypeInObjectParamsCreate) {
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    scoped_ptr<base::DictionaryValue> param_object_value(
-        new base::DictionaryValue());
-    param_object_value->Set("testType", CreateTestTypeDictionary().release());
-    param_object_value->Set("boolean", new base::FundamentalValue(true));
-    params_value->Append(param_object_value.release());
-    scoped_ptr<TestTypeInObject::Params> params(
-        TestTypeInObject::Params::Create(*params_value));
-    EXPECT_TRUE(params.get());
-    EXPECT_TRUE(params->param_object.test_type.get());
-    EXPECT_TRUE(params->param_object.boolean);
-    EXPECT_TRUE(CreateTestTypeDictionary()->Equals(
-          params->param_object.test_type->ToValue().get()));
-  }
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    scoped_ptr<base::DictionaryValue> param_object_value(
-        new base::DictionaryValue());
-    param_object_value->Set("boolean", new base::FundamentalValue(true));
-    params_value->Append(param_object_value.release());
-    scoped_ptr<TestTypeInObject::Params> params(
-        TestTypeInObject::Params::Create(*params_value));
-    EXPECT_TRUE(params.get());
-    EXPECT_FALSE(params->param_object.test_type.get());
-    EXPECT_TRUE(params->param_object.boolean);
-  }
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    scoped_ptr<base::DictionaryValue> param_object_value(
-        new base::DictionaryValue());
-    param_object_value->Set("testType", new base::StringValue("invalid"));
-    param_object_value->Set("boolean", new base::FundamentalValue(true));
-    params_value->Append(param_object_value.release());
-    scoped_ptr<TestTypeInObject::Params> params(
-        TestTypeInObject::Params::Create(*params_value));
-    EXPECT_FALSE(params.get());
-  }
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    scoped_ptr<base::DictionaryValue> param_object_value(
-        new base::DictionaryValue());
-    param_object_value->Set("testType", CreateTestTypeDictionary().release());
-    params_value->Append(param_object_value.release());
-    scoped_ptr<TestTypeInObject::Params> params(
-        TestTypeInObject::Params::Create(*params_value));
-    EXPECT_FALSE(params.get());
-  }
-}
diff --git a/tools/json_schema_compiler/test/dependency_tester.json b/tools/json_schema_compiler/test/dependency_tester.json
deleted file mode 100644
index 4845136..0000000
--- a/tools/json_schema_compiler/test/dependency_tester.json
+++ /dev/null
@@ -1,33 +0,0 @@
-// 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.
-
-[
-  {
-    "namespace": "dependencyTester",
-    "description": "An API for testing dependencies.",
-    "dependencies": [ "browserAction", "fontSettings" ],
-    "types": [],
-    "functions": [
-      {
-        "name": "setTitle",
-        "type": "function",
-        "description": "hi",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "color": {
-                "$ref": "browserAction.ColorArray"
-              },
-              "scriptCode": {
-                "$ref": "fontSettings.FakeStringType"
-              }
-            }
-          }
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/test/enums.json b/tools/json_schema_compiler/test/enums.json
deleted file mode 100644
index c776313..0000000
--- a/tools/json_schema_compiler/test/enums.json
+++ /dev/null
@@ -1,265 +0,0 @@
-[
-  {
-    "namespace": "enums",
-    "description": "The enums API.",
-    "types": [
-      {
-        "id": "Enumeration",
-        "type": "string",
-        "enum": ["one", "two", "three"]
-      },
-      {
-        "id": "EnumType",
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string",
-            "enum": ["one", "two", "three"]
-          }
-        }
-      },
-      {
-        "id": "HasEnumeration",
-        "type": "object",
-        "properties": {
-          "enumeration": {
-            "$ref": "Enumeration"
-          },
-          "optional_enumeration": {
-            "$ref": "Enumeration",
-            "optional": true
-          }
-        }
-      },
-      {
-        "id": "InlineAndReferenceEnum",
-        "type": "object",
-        "properties": {
-          "inline_enum": {
-            "type": "string",
-            "enum": ["test1", "test2", "test3"]
-          },
-          "reference_enum": {
-            "$ref": "Enumeration"
-          }
-        }
-      },
-      {
-        "id": "OptionalEnumType",
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string",
-            "enum": ["one", "two", "three"],
-            "optional": true
-          }
-        }
-      }
-    ],
-    "functions": [
-      {
-        "name": "takesEnum",
-        "type": "function",
-        "description": "Takes an enum as its parameter.",
-        "parameters": [
-          {
-            "name": "state",
-            "type": "string",
-            "enum": ["foo", "bar", "baz"]
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "takesEnumArray",
-        "type": "function",
-        "description": "Takes an enum array as its parameter.",
-        "parameters": [
-          {
-            "name": "values",
-            "type": "array",
-            "items": {
-              "type": "string",
-              "enum": ["foo", "bar", "baz"]
-            }
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "takesEnumAsType",
-        "type": "function",
-        "description": "Takes an enum type as its parameter.",
-        "parameters": [
-          {
-            "name": "enumeration",
-            "$ref": "Enumeration"
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "takesEnumArrayAsType",
-        "type": "function",
-        "description": "Takes an enum type array as its parameter.",
-        "parameters": [
-          {
-            "name": "values",
-            "type": "array",
-            "items": {
-              "$ref": "Enumeration"
-            }
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "returnsEnum",
-        "type": "function",
-        "description": "Returns an enum through the callback",
-        "parameters": [
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-              {
-                "name": "state",
-                "type": "string",
-                "enum": ["foo", "bar", "baz"]
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "returnsEnumAsType",
-        "type": "function",
-        "description": "Returns an enum through the callback",
-        "parameters": [
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-              {
-                "name": "enumeration",
-                "$ref": "Enumeration"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "returnsTwoEnums",
-        "type": "function",
-        "description": "Returns two enums through the callback",
-        "parameters": [
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-              {
-                "name": "firstState",
-                "type": "string",
-                "enum": ["foo", "bar", "baz"]
-              },
-              {
-                "name": "secondState",
-                "type": "string",
-                "enum": ["spam", "ham", "eggs"]
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "takesOptionalEnum",
-        "type": "function",
-        "description": "Takes an enum as its parameter.",
-        "parameters": [
-          {
-            "name": "state",
-            "type": "string",
-            "enum": ["foo", "bar", "baz"],
-            "optional": true
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "takesMultipleOptionalEnums",
-        "type": "function",
-        "description": "Takes two enums as parameters.",
-        "parameters": [
-          {
-            "name": "state",
-            "type": "string",
-            "enum": ["foo", "bar", "baz"],
-            "optional": true
-          },
-          {
-            "name": "type",
-            "type": "string",
-            "enum": ["foo", "ding", "dong"],
-            "optional": true
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      }
-    ],
-    "events": [
-      {
-        "name": "onEnumFired",
-        "type": "function",
-        "description": "Fired when an enum is ready.",
-        "parameters": [
-          {
-            "name": "someEnum",
-            "type": "string",
-            "enum": ["foo", "bar", "baz"]
-          }
-        ]
-      },
-      {
-        "name": "onTwoEnumsFired",
-        "type": "function",
-        "description": "Fired when two enums are ready.",
-        "parameters": [
-          {
-            "name": "firstEnum",
-            "type": "string",
-            "enum": ["foo", "bar", "baz"]
-          },
-          {
-            "name": "secondEnum",
-            "type": "string",
-            "enum": ["spam", "ham", "eggs"]
-          }
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/test/enums_unittest.cc b/tools/json_schema_compiler/test/enums_unittest.cc
deleted file mode 100644
index 7f1addb..0000000
--- a/tools/json_schema_compiler/test/enums_unittest.cc
+++ /dev/null
@@ -1,278 +0,0 @@
-// 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.
-
-#include "tools/json_schema_compiler/test/enums.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-#include "tools/json_schema_compiler/test/test_util.h"
-
-using namespace test::api::enums;
-using json_schema_compiler::test_util::List;
-
-TEST(JsonSchemaCompilerEnumsTest, EnumTypePopulate) {
-  {
-    EnumType enum_type;
-    base::DictionaryValue value;
-    value.Set("type", new base::StringValue("one"));
-    EXPECT_TRUE(EnumType::Populate(value, &enum_type));
-    EXPECT_EQ(EnumType::TYPE_ONE, enum_type.type);
-    EXPECT_TRUE(value.Equals(enum_type.ToValue().get()));
-  }
-  {
-    EnumType enum_type;
-    base::DictionaryValue value;
-    value.Set("type", new base::StringValue("invalid"));
-    EXPECT_FALSE(EnumType::Populate(value, &enum_type));
-  }
-}
-
-TEST(JsonSchemaCompilerEnumsTest, EnumsAsTypes) {
-  {
-    base::ListValue args;
-    args.Append(new base::StringValue("one"));
-
-    scoped_ptr<TakesEnumAsType::Params> params(
-        TakesEnumAsType::Params::Create(args));
-    ASSERT_TRUE(params.get());
-    EXPECT_EQ(ENUMERATION_ONE, params->enumeration);
-
-    EXPECT_TRUE(args.Equals(ReturnsEnumAsType::Results::Create(
-        ENUMERATION_ONE).get()));
-  }
-  {
-    HasEnumeration enumeration;
-    EXPECT_EQ(ENUMERATION_NONE, enumeration.enumeration);
-    EXPECT_EQ(ENUMERATION_NONE, enumeration.optional_enumeration);
-  }
-  {
-    HasEnumeration enumeration;
-    base::DictionaryValue value;
-    ASSERT_FALSE(HasEnumeration::Populate(value, &enumeration));
-
-    value.Set("enumeration", new base::StringValue("one"));
-    ASSERT_TRUE(HasEnumeration::Populate(value, &enumeration));
-    EXPECT_TRUE(value.Equals(enumeration.ToValue().get()));
-
-    value.Set("optional_enumeration", new base::StringValue("two"));
-    ASSERT_TRUE(HasEnumeration::Populate(value, &enumeration));
-    EXPECT_TRUE(value.Equals(enumeration.ToValue().get()));
-  }
-  {
-    InlineAndReferenceEnum enumeration;
-    base::DictionaryValue value;
-    ASSERT_FALSE(InlineAndReferenceEnum::Populate(value, &enumeration));
-
-    value.Set("inline_enum", new base::StringValue("test2"));
-    ASSERT_FALSE(InlineAndReferenceEnum::Populate(value, &enumeration));
-
-    value.Set("reference_enum", new base::StringValue("one"));
-    ASSERT_TRUE(InlineAndReferenceEnum::Populate(value, &enumeration));
-    EXPECT_TRUE(value.Equals(enumeration.ToValue().get()));
-  }
-}
-
-TEST(JsonSchemaCompilerEnumsTest, EnumsArrayAsType) {
-  {
-    base::ListValue params_value;
-    params_value.Append(List(new base::StringValue("one"),
-                             new base::StringValue("two")).release());
-    scoped_ptr<TakesEnumArrayAsType::Params> params(
-        TakesEnumArrayAsType::Params::Create(params_value));
-    ASSERT_TRUE(params);
-    EXPECT_EQ(2U, params->values.size());
-    EXPECT_EQ(ENUMERATION_ONE, params->values[0]);
-    EXPECT_EQ(ENUMERATION_TWO, params->values[1]);
-  }
-  {
-    base::ListValue params_value;
-    params_value.Append(List(new base::StringValue("invalid")).release());
-    scoped_ptr<TakesEnumArrayAsType::Params> params(
-        TakesEnumArrayAsType::Params::Create(params_value));
-    EXPECT_FALSE(params);
-  }
-}
-
-TEST(JsonSchemaCompilerEnumsTest, ReturnsEnumCreate) {
-  {
-    ReturnsEnum::Results::State state = ReturnsEnum::Results::STATE_FOO;
-    scoped_ptr<base::Value> result(
-        new base::StringValue(ReturnsEnum::Results::ToString(state)));
-    scoped_ptr<base::Value> expected(new base::StringValue("foo"));
-    EXPECT_TRUE(result->Equals(expected.get()));
-  }
-  {
-    ReturnsEnum::Results::State state = ReturnsEnum::Results::STATE_FOO;
-    scoped_ptr<base::ListValue> results = ReturnsEnum::Results::Create(state);
-    base::ListValue expected;
-    expected.Append(new base::StringValue("foo"));
-    EXPECT_TRUE(results->Equals(&expected));
-  }
-}
-
-TEST(JsonSchemaCompilerEnumsTest, ReturnsTwoEnumsCreate) {
-  {
-    scoped_ptr<base::ListValue> results = ReturnsTwoEnums::Results::Create(
-        ReturnsTwoEnums::Results::FIRST_STATE_FOO,
-        ReturnsTwoEnums::Results::SECOND_STATE_HAM);
-    base::ListValue expected;
-    expected.Append(new base::StringValue("foo"));
-    expected.Append(new base::StringValue("ham"));
-    EXPECT_TRUE(results->Equals(&expected));
-  }
-}
-
-TEST(JsonSchemaCompilerEnumsTest, OptionalEnumTypePopulate) {
-  {
-    OptionalEnumType enum_type;
-    base::DictionaryValue value;
-    value.Set("type", new base::StringValue("two"));
-    EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type));
-    EXPECT_EQ(OptionalEnumType::TYPE_TWO, enum_type.type);
-    EXPECT_TRUE(value.Equals(enum_type.ToValue().get()));
-  }
-  {
-    OptionalEnumType enum_type;
-    base::DictionaryValue value;
-    EXPECT_TRUE(OptionalEnumType::Populate(value, &enum_type));
-    EXPECT_EQ(OptionalEnumType::TYPE_NONE, enum_type.type);
-    EXPECT_TRUE(value.Equals(enum_type.ToValue().get()));
-  }
-  {
-    OptionalEnumType enum_type;
-    base::DictionaryValue value;
-    value.Set("type", new base::StringValue("invalid"));
-    EXPECT_FALSE(OptionalEnumType::Populate(value, &enum_type));
-  }
-}
-
-TEST(JsonSchemaCompilerEnumsTest, TakesEnumParamsCreate) {
-  {
-    base::ListValue params_value;
-    params_value.Append(new base::StringValue("baz"));
-    scoped_ptr<TakesEnum::Params> params(
-        TakesEnum::Params::Create(params_value));
-    EXPECT_TRUE(params.get());
-    EXPECT_EQ(TakesEnum::Params::STATE_BAZ, params->state);
-  }
-  {
-    base::ListValue params_value;
-    params_value.Append(new base::StringValue("invalid"));
-    scoped_ptr<TakesEnum::Params> params(
-        TakesEnum::Params::Create(params_value));
-    EXPECT_FALSE(params.get());
-  }
-}
-
-TEST(JsonSchemaCompilerEnumsTest, TakesEnumArrayParamsCreate) {
-  {
-    base::ListValue params_value;
-    params_value.Append(List(new base::StringValue("foo"),
-                             new base::StringValue("bar")).release());
-    scoped_ptr<TakesEnumArray::Params> params(
-        TakesEnumArray::Params::Create(params_value));
-    ASSERT_TRUE(params);
-    EXPECT_EQ(2U, params->values.size());
-    EXPECT_EQ(TakesEnumArray::Params::VALUES_TYPE_FOO, params->values[0]);
-    EXPECT_EQ(TakesEnumArray::Params::VALUES_TYPE_BAR, params->values[1]);
-  }
-  {
-    base::ListValue params_value;
-    params_value.Append(List(new base::StringValue("invalid")).release());
-    scoped_ptr<TakesEnumArray::Params> params(
-        TakesEnumArray::Params::Create(params_value));
-    EXPECT_FALSE(params);
-  }
-}
-
-TEST(JsonSchemaCompilerEnumsTest, TakesOptionalEnumParamsCreate) {
-  {
-    base::ListValue params_value;
-    params_value.Append(new base::StringValue("baz"));
-    scoped_ptr<TakesOptionalEnum::Params> params(
-        TakesOptionalEnum::Params::Create(params_value));
-    EXPECT_TRUE(params.get());
-    EXPECT_EQ(TakesOptionalEnum::Params::STATE_BAZ, params->state);
-  }
-  {
-    base::ListValue params_value;
-    scoped_ptr<TakesOptionalEnum::Params> params(
-        TakesOptionalEnum::Params::Create(params_value));
-    EXPECT_TRUE(params.get());
-    EXPECT_EQ(TakesOptionalEnum::Params::STATE_NONE, params->state);
-  }
-  {
-    base::ListValue params_value;
-    params_value.Append(new base::StringValue("invalid"));
-    scoped_ptr<TakesOptionalEnum::Params> params(
-        TakesOptionalEnum::Params::Create(params_value));
-    EXPECT_FALSE(params.get());
-  }
-}
-
-TEST(JsonSchemaCompilerEnumsTest, TakesMultipleOptionalEnumsParamsCreate) {
-  {
-    base::ListValue params_value;
-    params_value.Append(new base::StringValue("foo"));
-    params_value.Append(new base::StringValue("foo"));
-    scoped_ptr<TakesMultipleOptionalEnums::Params> params(
-        TakesMultipleOptionalEnums::Params::Create(params_value));
-    EXPECT_TRUE(params.get());
-    EXPECT_EQ(TakesMultipleOptionalEnums::Params::STATE_FOO, params->state);
-    EXPECT_EQ(TakesMultipleOptionalEnums::Params::TYPE_FOO, params->type);
-  }
-  {
-    base::ListValue params_value;
-    params_value.Append(new base::StringValue("foo"));
-    scoped_ptr<TakesMultipleOptionalEnums::Params> params(
-        TakesMultipleOptionalEnums::Params::Create(params_value));
-    EXPECT_TRUE(params.get());
-    EXPECT_EQ(TakesMultipleOptionalEnums::Params::STATE_FOO, params->state);
-    EXPECT_EQ(TakesMultipleOptionalEnums::Params::TYPE_NONE, params->type);
-  }
-  {
-    base::ListValue params_value;
-    scoped_ptr<TakesMultipleOptionalEnums::Params> params(
-        TakesMultipleOptionalEnums::Params::Create(params_value));
-    EXPECT_TRUE(params.get());
-    EXPECT_EQ(TakesMultipleOptionalEnums::Params::STATE_NONE, params->state);
-    EXPECT_EQ(TakesMultipleOptionalEnums::Params::TYPE_NONE, params->type);
-  }
-  {
-    base::ListValue params_value;
-    params_value.Append(new base::StringValue("baz"));
-    params_value.Append(new base::StringValue("invalid"));
-    scoped_ptr<TakesMultipleOptionalEnums::Params> params(
-        TakesMultipleOptionalEnums::Params::Create(params_value));
-    EXPECT_FALSE(params.get());
-  }
-}
-
-TEST(JsonSchemaCompilerEnumsTest, OnEnumFiredCreate) {
-  {
-    OnEnumFired::SomeEnum some_enum = OnEnumFired::SOME_ENUM_FOO;
-    scoped_ptr<base::Value> result(
-        new base::StringValue(OnEnumFired::ToString(some_enum)));
-    scoped_ptr<base::Value> expected(new base::StringValue("foo"));
-    EXPECT_TRUE(result->Equals(expected.get()));
-  }
-  {
-    OnEnumFired::SomeEnum some_enum = OnEnumFired::SOME_ENUM_FOO;
-    scoped_ptr<base::ListValue> results(OnEnumFired::Create(some_enum));
-    base::ListValue expected;
-    expected.Append(new base::StringValue("foo"));
-    EXPECT_TRUE(results->Equals(&expected));
-  }
-}
-
-TEST(JsonSchemaCompilerEnumsTest, OnTwoEnumsFiredCreate) {
-  {
-    scoped_ptr<base::Value> results(OnTwoEnumsFired::Create(
-        OnTwoEnumsFired::FIRST_ENUM_FOO,
-        OnTwoEnumsFired::SECOND_ENUM_HAM));
-    base::ListValue expected;
-    expected.Append(new base::StringValue("foo"));
-    expected.Append(new base::StringValue("ham"));
-    EXPECT_TRUE(results->Equals(&expected));
-  }
-}
diff --git a/tools/json_schema_compiler/test/error_generation.json b/tools/json_schema_compiler/test/error_generation.json
deleted file mode 100644
index f90ef6e..0000000
--- a/tools/json_schema_compiler/test/error_generation.json
+++ /dev/null
@@ -1,152 +0,0 @@
-[
-  {
-    "namespace": "error_generation",
-    "description": "Generates ALL the errors.",
-    "compiler_options": {
-      "generate_error_messages": true
-    },
-    "types": [
-      {
-        "id": "TestType",
-        "type": "object",
-        "properties": {
-          "string": {
-            "type": "string",
-            "description": "Some string."
-          }
-        }
-      },
-      {
-        "id": "OptionalTestType",
-        "type": "object",
-        "properties": {
-          "string": {
-            "type": "string",
-            "description": "Some string.",
-            "optional": true
-          }
-        }
-      },
-      {
-        "id": "ChoiceType",
-        "type": "object",
-        "properties": {
-          "integers": {
-            "choices": [
-               {"type": "array", "items": {"type": "integer", "minimum": 0}},
-               {"type": "integer"}
-            ]
-          }
-        }
-      },
-      {
-        "id": "OptionalChoiceType",
-        "type": "object",
-        "properties": {
-          "integers": {
-            "choices": [
-               {"type": "array", "items": {"type": "integer", "minimum": 0}},
-               {"type": "integer"}
-            ],
-            "optional": true
-          }
-        }
-      },
-      {
-        "id": "ObjectType",
-        "type": "object",
-        "properties": {
-          "otherType": {
-            "$ref": "error_generation.TestType",
-            "optional": true
-          }
-        }
-      },
-      {
-        "id": "Enumeration",
-        "type": "string",
-        "enum": ["one", "two", "three"]
-      },
-      {
-        "id": "HasEnumeration",
-        "type": "object",
-        "properties": {
-          "enumeration": {
-            "$ref": "Enumeration"
-          }
-        }
-      },
-      {
-        "id": "BinaryData",
-        "type": "object",
-        "properties": {
-          "data": {
-            "type" : "binary"
-          }
-        }
-      },
-      {
-        "id": "OptionalBinaryData",
-        "type": "object",
-        "properties": {
-          "data": {
-            "type" : "binary",
-            "optional": true
-          }
-        }
-      },
-      {
-        "id": "ArrayObject",
-        "type": "object",
-        "properties": {
-          "TheArray": {
-            "type": "array",
-            "items": {"type": "string"},
-            "optional": true,
-            "description": "Expecting a list?"
-          }
-        }
-      }
-    ],
-    "functions": [
-      {
-        "name": "testString",
-        "type": "function",
-        "description": "Takes a string. Or not.",
-        "parameters": [
-          {
-            "name": "str",
-            "type": "string",
-            "optional": true
-          }
-        ]
-      },
-      {
-        "name": "testFunction",
-        "type": "function",
-        "description": "Specifies a number of parameters.",
-        "parameters": [
-          {
-            "name": "num",
-            "type": "integer"
-          }
-        ]
-      },
-      {
-        "name": "testTypeInObject",
-        "type": "function",
-        "description": "Takes a TestType.",
-        "parameters": [
-          {
-            "name": "paramObject",
-            "type": "object",
-            "properties": {
-              "testType": {"$ref": "error_generation.TestType", "optional": true},
-              "boolean": {"type": "boolean"}
-            }
-          }
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/test/error_generation_unittest.cc b/tools/json_schema_compiler/test/error_generation_unittest.cc
deleted file mode 100644
index 42f9576..0000000
--- a/tools/json_schema_compiler/test/error_generation_unittest.cc
+++ /dev/null
@@ -1,336 +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.
-
-#include "tools/json_schema_compiler/test/error_generation.h"
-
-#include "base/json/json_writer.h"
-#include "base/strings/utf_string_conversions.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "tools/json_schema_compiler/test/test_util.h"
-
-using namespace test::api::error_generation;
-using base::FundamentalValue;
-using json_schema_compiler::test_util::Dictionary;
-using json_schema_compiler::test_util::List;
-
-template <typename T>
-base::string16 GetPopulateError(const base::Value& value) {
-  base::string16 error;
-  T test_type;
-  T::Populate(value, &test_type, &error);
-  return error;
-}
-
-testing::AssertionResult EqualsUtf16(const std::string& expected,
-                                     const base::string16& actual) {
-  if (base::ASCIIToUTF16(expected) != actual)
-    return testing::AssertionFailure() << expected << " != " << actual;
-  return testing::AssertionSuccess();
-}
-
-// GenerateTypePopulate errors
-
-TEST(JsonSchemaCompilerErrorTest, RequiredPropertyPopulate) {
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "string", new base::StringValue("bling"));
-    EXPECT_TRUE(EqualsUtf16("", GetPopulateError<TestType>(*value)));
-  }
-  {
-    scoped_ptr<base::BinaryValue> value(new base::BinaryValue());
-    EXPECT_TRUE(EqualsUtf16("expected dictionary, got binary",
-        GetPopulateError<TestType>(*value)));
-  }
-}
-
-TEST(JsonSchemaCompilerErrorTest, UnexpectedTypePopulation) {
-  {
-    scoped_ptr<base::ListValue> value(new base::ListValue());
-    EXPECT_TRUE(EqualsUtf16("",
-        GetPopulateError<ChoiceType::Integers>(*value)));
-  }
-  {
-    scoped_ptr<base::BinaryValue> value(new base::BinaryValue());
-    EXPECT_TRUE(EqualsUtf16("expected integers or integer, got binary",
-        GetPopulateError<ChoiceType::Integers>(*value)));
-  }
-}
-
-// GenerateTypePopulateProperty errors
-
-TEST(JsonSchemaCompilerErrorTest, TypeIsRequired) {
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "integers", new FundamentalValue(5));
-    EXPECT_TRUE(EqualsUtf16("", GetPopulateError<ChoiceType>(*value)));
-  }
-  {
-    scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-    EXPECT_TRUE(EqualsUtf16("'integers' is required",
-        GetPopulateError<ChoiceType>(*value)));
-  }
-}
-
-// GenerateParamsCheck errors
-
-TEST(JsonSchemaCompilerErrorTest, TooManyParameters) {
-  {
-    scoped_ptr<base::ListValue> params_value = List(
-        new FundamentalValue(5));
-    base::string16 error;
-    EXPECT_TRUE(TestFunction::Params::Create(*params_value, &error));
-  }
-  {
-    scoped_ptr<base::ListValue> params_value = List(
-        new FundamentalValue(5),
-        new FundamentalValue(5));
-    base::string16 error;
-    EXPECT_FALSE(TestFunction::Params::Create(*params_value, &error));
-    EXPECT_TRUE(EqualsUtf16("expected 1 arguments, got 2", error));
-  }
-}
-
-// GenerateFunctionParamsCreate errors
-
-TEST(JsonSchemaCompilerErrorTest, ParamIsRequired) {
-  {
-    scoped_ptr<base::ListValue> params_value = List(
-        new FundamentalValue(5));
-    base::string16 error;
-    EXPECT_TRUE(TestFunction::Params::Create(*params_value, &error));
-  }
-  {
-    scoped_ptr<base::ListValue> params_value = List(
-        base::Value::CreateNullValue());
-    base::string16 error;
-    EXPECT_FALSE(TestFunction::Params::Create(*params_value, &error));
-    EXPECT_TRUE(EqualsUtf16("'num' is required", error));
-  }
-}
-
-// GeneratePopulateVariableFromValue errors
-
-TEST(JsonSchemaCompilerErrorTest, WrongPropertyValueType) {
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-      "string", new base::StringValue("yes"));
-    EXPECT_TRUE(EqualsUtf16("", GetPopulateError<TestType>(*value)));
-  }
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "string", new FundamentalValue(1.1));
-    EXPECT_TRUE(EqualsUtf16("'string': expected string, got number",
-        GetPopulateError<TestType>(*value)));
-  }
-}
-
-TEST(JsonSchemaCompilerErrorTest, WrongParameterCreationType) {
-  {
-    base::string16 error;
-    scoped_ptr<base::ListValue> params_value = List(
-        new base::StringValue("Yeah!"));
-    EXPECT_TRUE(TestString::Params::Create(*params_value, &error));
-  }
-  {
-    scoped_ptr<base::ListValue> params_value = List(
-        new FundamentalValue(5));
-    base::string16 error;
-    EXPECT_FALSE(TestTypeInObject::Params::Create(*params_value, &error));
-    EXPECT_TRUE(EqualsUtf16("'paramObject': expected dictionary, got integer",
-        error));
-  }
-}
-
-TEST(JsonSchemaCompilerErrorTest, WrongTypeValueType) {
-  {
-    scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-    EXPECT_TRUE(EqualsUtf16("", GetPopulateError<ObjectType>(*value)));
-  }
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "otherType", new FundamentalValue(1.1));
-    ObjectType out;
-    base::string16 error;
-    EXPECT_TRUE(ObjectType::Populate(*value, &out, &error));
-    EXPECT_TRUE(EqualsUtf16("'otherType': expected dictionary, got number",
-        error));
-    EXPECT_EQ(NULL, out.other_type.get());
-  }
-}
-
-TEST(JsonSchemaCompilerErrorTest, UnableToPopulateArray) {
-  {
-    scoped_ptr<base::ListValue> params_value = List(
-        new FundamentalValue(5));
-    EXPECT_TRUE(EqualsUtf16("",
-        GetPopulateError<ChoiceType::Integers>(*params_value)));
-  }
-  {
-    scoped_ptr<base::ListValue> params_value = List(
-        new FundamentalValue(5),
-        new FundamentalValue(false));
-    EXPECT_TRUE(EqualsUtf16("unable to populate array 'integers'",
-        GetPopulateError<ChoiceType::Integers>(*params_value)));
-  }
-}
-
-TEST(JsonSchemaCompilerErrorTest, BinaryTypeExpected) {
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "data", new base::BinaryValue());
-    EXPECT_TRUE(EqualsUtf16("", GetPopulateError<BinaryData>(*value)));
-  }
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "data", new FundamentalValue(1.1));
-    EXPECT_TRUE(EqualsUtf16("'data': expected binary, got number",
-        GetPopulateError<BinaryData>(*value)));
-  }
-}
-
-TEST(JsonSchemaCompilerErrorTest, ListExpected) {
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "TheArray", new base::ListValue());
-    EXPECT_TRUE(EqualsUtf16("", GetPopulateError<ArrayObject>(*value)));
-  }
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "TheArray", new FundamentalValue(5));
-    EXPECT_TRUE(EqualsUtf16("'TheArray': expected list, got integer",
-        GetPopulateError<ArrayObject>(*value)));
-  }
-}
-
-// GenerateStringToEnumConversion errors
-
-TEST(JsonSchemaCompilerErrorTest, BadEnumValue) {
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "enumeration", new base::StringValue("one"));
-    EXPECT_TRUE(EqualsUtf16("", GetPopulateError<HasEnumeration>(*value)));
-  }
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "enumeration", new base::StringValue("bad sauce"));
-    EXPECT_TRUE(EqualsUtf16("'Enumeration': expected \"one\" or \"two\" "
-              "or \"three\", got \"bad sauce\"",
-        GetPopulateError<HasEnumeration>(*value)));
-  }
-}
-
-// Warn but don't fail out errors
-
-TEST(JsonSchemaCompilerErrorTest, WarnOnOptionalFailure) {
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "string", new base::StringValue("bling"));
-    EXPECT_TRUE(EqualsUtf16("", GetPopulateError<OptionalTestType>(*value)));
-  }
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "string", new base::FundamentalValue(1));
-
-    OptionalTestType out;
-    base::string16 error;
-    EXPECT_TRUE(OptionalTestType::Populate(*value, &out, &error));
-    EXPECT_TRUE(EqualsUtf16("'string': expected string, got integer",
-        error));
-    EXPECT_EQ(NULL, out.string.get());
-  }
-}
-
-TEST(JsonSchemaCompilerErrorTest, OptionalBinaryTypeFailure) {
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "data", new base::BinaryValue());
-    EXPECT_TRUE(EqualsUtf16("", GetPopulateError<OptionalBinaryData>(*value)));
-  }
-  {
-    // There's a bug with silent failures if the key doesn't exist.
-    scoped_ptr<base::DictionaryValue> value = Dictionary("data",
-        new base::FundamentalValue(1));
-
-    OptionalBinaryData out;
-    base::string16 error;
-    EXPECT_TRUE(OptionalBinaryData::Populate(*value, &out, &error));
-    EXPECT_TRUE(EqualsUtf16("'data': expected binary, got integer",
-        error));
-    EXPECT_EQ(NULL, out.data.get());
-  }
-}
-
-TEST(JsonSchemaCompilerErrorTest, OptionalArrayTypeFailure) {
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "TheArray", new base::ListValue());
-    EXPECT_TRUE(EqualsUtf16("", GetPopulateError<ArrayObject>(*value)));
-  }
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "TheArray", new FundamentalValue(5));
-    ArrayObject out;
-    base::string16 error;
-    EXPECT_TRUE(ArrayObject::Populate(*value, &out, &error));
-    EXPECT_TRUE(EqualsUtf16("'TheArray': expected list, got integer",
-        error));
-    EXPECT_EQ(NULL, out.the_array.get());
-  }
-}
-
-TEST(JsonSchemaCompilerErrorTest, OptionalUnableToPopulateArray) {
-  {
-    scoped_ptr<base::ListValue> params_value = List(
-        new FundamentalValue(5));
-    EXPECT_TRUE(EqualsUtf16("",
-        GetPopulateError<OptionalChoiceType::Integers>(*params_value)));
-  }
-  {
-    scoped_ptr<base::ListValue> params_value = List(
-        new FundamentalValue(5),
-        new FundamentalValue(false));
-    OptionalChoiceType::Integers out;
-    base::string16 error;
-    EXPECT_TRUE(OptionalChoiceType::Integers::Populate(*params_value, &out,
-        &error));
-    EXPECT_TRUE(EqualsUtf16("unable to populate array 'integers'",
-        error));
-    EXPECT_EQ(NULL, out.as_integer.get());
-  }
-}
-
-TEST(JsonSchemaCompilerErrorTest, MultiplePopulationErrors) {
-  {
-
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "TheArray", new FundamentalValue(5));
-    ArrayObject out;
-    base::string16 error;
-    EXPECT_TRUE(ArrayObject::Populate(*value, &out, &error));
-    EXPECT_TRUE(EqualsUtf16("'TheArray': expected list, got integer",
-        error));
-    EXPECT_EQ(NULL, out.the_array.get());
-
-    EXPECT_TRUE(ArrayObject::Populate(*value, &out, &error));
-    EXPECT_TRUE(EqualsUtf16("'TheArray': expected list, got integer; "
-        "'TheArray': expected list, got integer",
-        error));
-    EXPECT_EQ(NULL, out.the_array.get());
-  }
-}
-
-TEST(JsonSchemaCompilerErrorTest, TooManyKeys) {
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-      "string", new base::StringValue("yes"));
-    EXPECT_TRUE(EqualsUtf16("", GetPopulateError<TestType>(*value)));
-  }
-  {
-    scoped_ptr<base::DictionaryValue> value = Dictionary(
-        "string", new base::StringValue("yes"),
-        "ohno", new base::StringValue("many values"));
-    EXPECT_TRUE(EqualsUtf16("found unexpected key 'ohno'",
-        GetPopulateError<TestType>(*value)));
-  }
-}
diff --git a/tools/json_schema_compiler/test/features_unittest.cc b/tools/json_schema_compiler/test/features_unittest.cc
deleted file mode 100644
index c4f1f12..0000000
--- a/tools/json_schema_compiler/test/features_unittest.cc
+++ /dev/null
@@ -1,22 +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.
-
-#include <string>
-
-#include "testing/gtest/include/gtest/gtest.h"
-#include "tools/json_schema_compiler/test/test_features.h"
-
-using test::features::TestFeatures;
-
-TEST(FeaturesGeneratorTest, FromString) {
-  TestFeatures test_features;
-  EXPECT_EQ(TestFeatures::kSimple, test_features.FromString("simple"));
-  EXPECT_EQ(TestFeatures::kComplex, test_features.FromString("complex"));
-}
-
-TEST(FeaturesGeneratorTest, ToString) {
-  TestFeatures test_features;
-  EXPECT_STREQ("simple", test_features.ToString(TestFeatures::kSimple));
-  EXPECT_STREQ("complex", test_features.ToString(TestFeatures::kComplex));
-}
diff --git a/tools/json_schema_compiler/test/font_settings.json b/tools/json_schema_compiler/test/font_settings.json
deleted file mode 100644
index 01c49f7..0000000
--- a/tools/json_schema_compiler/test/font_settings.json
+++ /dev/null
@@ -1,551 +0,0 @@
-// 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.
-
-[
-  {
-    "namespace": "fontSettings",
-    "description": "The fontSettings API.",
-    "types": [
-      {
-        "id": "FontName",
-        "type": "object",
-        "description": "Represents a font name.",
-        "properties": {
-          "fontName": {
-            "type": "string",
-            "description": "The font name."
-          },
-          "localizedName": {
-            "type": "string",
-            "description": "The font name localized for the current locale."
-          }
-        }
-      },
-      {
-        "id": "FakeStringType",
-        "type": "string",
-        "description": "Used to test a string type."
-      },
-      {
-        "id": "GenericFamily",
-        "type": "string",
-        "enum": ["standard", "sansserif", "serif", "fixed", "cursive", "fantasy"],
-        "description": "A CSS generic font family."
-      },
-      {
-        "id": "LevelOfControl",
-        "description": "One of<br><var>not_controllable</var>: cannot be controlled by any extension<br><var>controlled_by_other_extensions</var>: controlled by extensions with higher precedence<br><var>controllable_by_this_extension</var>: can be controlled by this extension<br><var>controlled_by_this_extension</var>: controlled by this extension",
-        "type": "string",
-        "enum": ["not_controllable", "controlled_by_other_extensions", "controllable_by_this_extension", "controlled_by_this_extension"]
-      }
-    ],
-    "functions": [
-      {
-        "name": "clearFont",
-        "description": "Clears the font set by this extension, if any.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "script": {
-                "$ref": "FakeStringType",
-                "description": "The script for which the font should be cleared. If omitted, the global script font setting is cleared.",
-                "optional": true
-              },
-              "genericFamily": {
-                "$ref": "GenericFamily",
-                "description": "The generic font family for which the font should be cleared."
-              }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "getFont",
-        "description": "Gets the font for a given script and generic font family.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "script": {
-                "$ref": "FakeStringType",
-                "description": "The script for which the font should be retrieved. If omitted, the font for the global script is retrieved.",
-                "optional": true
-              },
-              "genericFamily": {
-                "$ref": "GenericFamily",
-                "description": "The generic font family for which the font should be retrieved."
-              }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "details",
-                "type": "object",
-                "properties": {
-                  "fontName": {
-                    "type": "string",
-                    "description": "The font name. Rather than the literal font name preference value, this may be the name of the font that the system resolves the preference value to. The empty string signifies fallback to the global script font setting."
-                  }
-                }
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "setFont",
-        "description": "Sets the font for a given script and generic font family.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "script": {
-                "$ref": "FakeStringType",
-                "description": "The script code which the font should be set. If omitted, the font for the global script is set.",
-                "optional": true
-              },
-              "genericFamily": {
-                "$ref": "GenericFamily",
-                "description": "The generic font family for which the font should be set."
-              },
-              "fontName": {
-                "type": "string",
-                "description": "The font name. If a script is specified, the empty string means to fallback to the global script font setting."
-              }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "getFontList",
-        "description": "Gets a list of fonts on the system.",
-        "parameters": [
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "results",
-                "type": "array",
-                "items": { "$ref": "FontName" }
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "clearDefaultFontSize",
-        "description": "Clears the default font size set by this extension, if any.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "optional": true,
-            "description": "This parameter is currently unused.",
-            "properties": {}
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "getDefaultFontSize",
-        "description": "Gets the default font size.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "optional": true,
-            "description": "This parameter is currently unused.",
-            "properties": {}
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "details",
-                "type": "object",
-                "properties": {
-                  "pixelSize": {
-                    "type": "integer",
-                    "description": "The font size in pixels."
-                  }
-                }
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "setDefaultFontSize",
-        "description": "Sets the default font size.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "pixelSize": {
-                "type": "integer",
-                "description": "The font size in pixels."
-              }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "clearDefaultFixedFontSize",
-        "description": "Clears the default fixed font size set by this extension, if any.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "optional": true,
-            "description": "This parameter is currently unused.",
-            "properties": {}
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "getDefaultFixedFontSize",
-        "description": "Gets the default size for fixed width fonts.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "optional": true,
-            "description": "This parameter is currently unused.",
-            "properties": {}
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "details",
-                "type": "object",
-                "properties": {
-                  "pixelSize": {
-                    "type": "integer",
-                    "description": "The font size in pixels."
-                  }
-                }
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "setDefaultFixedFontSize",
-        "description": "Sets the default size for fixed width fonts.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "pixelSize": {
-                "type": "integer",
-                "description": "The font size in pixels."
-              }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "clearMinimumFontSize",
-        "description": "Clears the minimum font size set by this extension, if any.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "optional": true,
-            "description": "This parameter is currently unused.",
-            "properties": {}
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "getMinimumFontSize",
-        "description": "Gets the minimum font size.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "optional": true,
-            "description": "This parameter is currently unused.",
-            "properties": {}
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "details",
-                "type": "object",
-                "properties": {
-                  "pixelSize": {
-                    "type": "integer",
-                    "description": "The font size in pixels."
-                  }
-                }
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "setMinimumFontSize",
-        "description": "Sets the minimum font size.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "pixelSize": {
-                "type": "integer",
-                "description": "The font size in pixels."
-              }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "clearDefaultCharacterSet",
-        "description": "Clears the default character set set by this extension, if any.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "optional": true,
-            "description": "This parameter is currently unused.",
-            "properties": {}
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "getDefaultCharacterSet",
-        "description": "Gets the default character set.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "optional": true,
-            "description": "This parameter is currently unused.",
-            "properties": {}
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "details",
-                "type": "object",
-                "properties": {
-                  "charset": {
-                    "type": "string",
-                    "description": "The default character set, such as \"ISO-8859-1\"."
-                  }
-                }
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "setDefaultCharacterSet",
-        "description": "Sets the default character set.",
-        "parameters": [
-          {
-            "name": "details",
-            "type": "object",
-            "properties": {
-              "charset": {
-                "type": "string",
-                "description": "The character set."
-              }
-            }
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "optional": true,
-            "parameters": []
-          }
-        ]
-      }
-    ],
-    "events": [
-      {
-        "name": "onFontChanged",
-        "description": "Fired when a font setting changes.",
-        "parameters": [
-          {
-            "type": "object",
-            "name": "details",
-            "properties": {
-              "fontName": { "type": "string" },
-              "script": {
-                "$ref": "FakeStringType",
-                "description": "The script code for which the font setting has changed. If omitted, the global script font setting has changed.",
-                "optional": true
-              },
-              "genericFamily": {
-                "$ref": "GenericFamily",
-                "description": "The generic font family for which the font setting has changed."
-              },
-              "levelOfControl": {
-                "$ref": "LevelOfControl",
-                "description": "The level of control this extension has over the setting."
-              }
-            }
-          }
-        ]
-      },
-      {
-        "name": "onDefaultFontSizeChanged",
-        "description": "Fired when the default font size setting changes.",
-        "parameters": [
-          {
-            "type": "object",
-            "name": "details",
-            "properties": {
-              "pixelSize": {
-                "type": "integer",
-                "description": "The font size in pixels."
-              },
-              "levelOfControl": {
-                "$ref": "LevelOfControl",
-                "description": "The level of control this extension has over the setting."
-              }
-            }
-          }
-        ]
-      },
-      {
-        "name": "onDefaultFixedFontSizeChanged",
-        "description": "Fired when the default fixed font size setting changes.",
-        "parameters": [
-          {
-            "type": "object",
-            "name": "details",
-            "properties": {
-              "pixelSize": {
-                "type": "integer",
-                "description": "The font size in pixels."
-              },
-              "levelOfControl": {
-                "$ref": "LevelOfControl",
-                "description": "The level of control this extension has over the setting."
-              }
-            }
-          }
-        ]
-      },
-      {
-        "name": "onMinimumFontSizeChanged",
-        "description": "Fired when the minimum font size setting changes.",
-        "parameters": [
-          {
-            "type": "object",
-            "name": "details",
-            "properties": {
-              "pixelSize": {
-                "type": "integer",
-                "description": "The font size in pixels."
-              },
-              "levelOfControl": {
-                "$ref": "LevelOfControl",
-                "description": "The level of control this extension has over the setting."
-              }
-            }
-          }
-        ]
-      },
-      {
-        "name": "onDefaultCharacterSetChanged",
-        "description": "Fired when the default character set setting changes.",
-        "parameters": [
-          {
-            "type": "object",
-            "name": "details",
-            "properties": {
-              "charset": {
-                "type": "string",
-                "description": "The character set."
-              },
-              "levelOfControl": {
-                "$ref": "LevelOfControl",
-                "description": "The level of control this extension has over the setting."
-              }
-            }
-          }
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/test/forbidden.json b/tools/json_schema_compiler/test/forbidden.json
deleted file mode 100644
index 841b0e1..0000000
--- a/tools/json_schema_compiler/test/forbidden.json
+++ /dev/null
@@ -1,40 +0,0 @@
-[
-  {
-    "namespace": "forbidden",
-    "description": "The forbidden API... Careful.",
-    "types": [],
-    "functions": [
-      {
-        "name": "forbiddenParameters",
-        "type": "function",
-        "description": "Don't do this at home. Accepts multiple choices and values",
-        "parameters": [
-          {
-            "name": "firstChoice",
-            "description": "a choice between int and array",
-            "choices": [
-              {"type": "integer", "minimum": 0},
-              {"type": "array", "items": {"type": "integer"}}
-            ]
-          },
-          {
-            "type": "string",
-            "name": "firstString"
-          },
-          {
-            "name": "secondChoice",
-            "description": "a choice between int and array",
-            "choices": [
-              {"type": "integer", "minimum": 0},
-              {"type": "array", "items": {"type": "integer"}}
-            ]
-          },
-          {
-            "type": "string",
-            "name": "secondString"
-          }
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/test/functions_as_parameters.json b/tools/json_schema_compiler/test/functions_as_parameters.json
deleted file mode 100644
index b948616..0000000
--- a/tools/json_schema_compiler/test/functions_as_parameters.json
+++ /dev/null
@@ -1,29 +0,0 @@
-[
-  {
-    "namespace": "functions_as_parameters",
-    "description": "The functionsAsParameters API",
-    "types": [
-      {
-        "id": "FunctionType",
-        "type": "object",
-        "properties": {
-          "event_callback": {
-            "type": "function",
-            "parameters": { }
-          }
-        }
-      },
-      {
-        "id": "OptionalFunctionType",
-        "type": "object",
-        "properties": {
-          "event_callback": {
-            "type": "function",
-            "optional": true,
-            "parameters": { }
-          }
-        }
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/test/functions_as_parameters_unittest.cc b/tools/json_schema_compiler/test/functions_as_parameters_unittest.cc
deleted file mode 100644
index ce7a2f9..0000000
--- a/tools/json_schema_compiler/test/functions_as_parameters_unittest.cc
+++ /dev/null
@@ -1,94 +0,0 @@
-// 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.
-
-#include "tools/json_schema_compiler/test/functions_as_parameters.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-using namespace test::api::functions_as_parameters;
-
-TEST(JsonSchemaCompilerFunctionsAsParametersTest, PopulateRequiredFunction) {
-  // The expectation is that if any value is set for the function, then
-  // the function is "present".
-  {
-    base::DictionaryValue empty_value;
-    FunctionType out;
-    EXPECT_FALSE(FunctionType::Populate(empty_value, &out));
-  }
-  {
-    base::DictionaryValue value;
-    base::DictionaryValue function_dict;
-    value.Set("event_callback", function_dict.DeepCopy());
-    FunctionType out;
-    ASSERT_TRUE(FunctionType::Populate(value, &out));
-    EXPECT_TRUE(out.event_callback.empty());
-  }
-}
-
-TEST(JsonSchemaCompilerFunctionsAsParametersTest, RequiredFunctionToValue) {
-  {
-    base::DictionaryValue value;
-    base::DictionaryValue function_dict;
-    value.Set("event_callback", function_dict.DeepCopy());
-
-    FunctionType out;
-    ASSERT_TRUE(FunctionType::Populate(value, &out));
-    EXPECT_TRUE(value.Equals(out.ToValue().get()));
-  }
-  {
-    base::DictionaryValue value;
-    base::DictionaryValue expected_value;
-    base::DictionaryValue function_dict;
-    value.Set("event_callback", function_dict.DeepCopy());
-    expected_value.Set("event_callback", function_dict.DeepCopy());
-
-    FunctionType out;
-    ASSERT_TRUE(FunctionType::Populate(value, &out));
-    EXPECT_TRUE(expected_value.Equals(out.ToValue().get()));
-  }
-}
-
-TEST(JsonSchemaCompilerFunctionsAsParametersTest, PopulateOptionalFunction) {
-  {
-    base::DictionaryValue empty_value;
-    OptionalFunctionType out;
-    ASSERT_TRUE(OptionalFunctionType::Populate(empty_value, &out));
-    EXPECT_FALSE(out.event_callback.get());
-  }
-  {
-    base::DictionaryValue value;
-    base::DictionaryValue function_value;
-    value.Set("event_callback", function_value.DeepCopy());
-    OptionalFunctionType out;
-    ASSERT_TRUE(OptionalFunctionType::Populate(value, &out));
-    EXPECT_TRUE(out.event_callback.get());
-  }
-  {
-    base::DictionaryValue value;
-    base::DictionaryValue function_value;
-    value.Set("event_callback", function_value.DeepCopy());
-    OptionalFunctionType out;
-    ASSERT_TRUE(OptionalFunctionType::Populate(value, &out));
-    EXPECT_TRUE(out.event_callback.get());
-  }
-}
-
-TEST(JsonSchemaCompilerFunctionsAsParametersTest, OptionalFunctionToValue) {
-  {
-    base::DictionaryValue empty_value;
-    OptionalFunctionType out;
-    ASSERT_TRUE(OptionalFunctionType::Populate(empty_value, &out));
-    // event_callback should not be set in the return from ToValue.
-    EXPECT_TRUE(empty_value.Equals(out.ToValue().get()));
-  }
-  {
-    base::DictionaryValue value;
-    base::DictionaryValue function_value;
-    value.Set("event_callback", function_value.DeepCopy());
-
-    OptionalFunctionType out;
-    ASSERT_TRUE(OptionalFunctionType::Populate(value, &out));
-    EXPECT_TRUE(value.Equals(out.ToValue().get()));
-  }
-}
diff --git a/tools/json_schema_compiler/test/functions_on_types.json b/tools/json_schema_compiler/test/functions_on_types.json
deleted file mode 100644
index a20a75f..0000000
--- a/tools/json_schema_compiler/test/functions_on_types.json
+++ /dev/null
@@ -1,75 +0,0 @@
-[
-  {
-    "namespace": "functionsOnTypes",
-    "description": "The functionsOnTypes API.",
-    "types": [
-      {
-        "id": "StorageArea",
-        "type": "object",
-        "functions": [
-          {
-            "name": "get",
-            "type": "function",
-            "description": "Gets one or more items from storage.",
-            "parameters": [
-              {
-                "name": "keys",
-                "choices": [
-                  { "type": "string" },
-                  {
-                    "type": "object",
-                    "description": "Storage items to return in the callback, where the values are replaced with those from storage if they exist.",
-                    "properties": {},
-                    "additionalProperties": { "type": "any" }
-                  }
-                ],
-                "description": "A single key to get, list of keys to get, or a dictionary specifying default values (see description of the object).  An empty list or object will return an empty result object.  Pass in <code>null</code> to get the entire contents of storage.",
-                "optional": true
-              },
-              {
-                "name": "callback",
-                "type": "function",
-                "description": "Callback with storage items, or on failure (in which case lastError will be set).",
-                "parameters": [
-                  {
-                    "name": "items",
-                    "type": "object",
-                    "properties": {},
-                    "additionalProperties": { "type": "any" },
-                    "description": "Object with items in their key-value mappings."
-                  }
-                ]
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "id": "ChromeSetting",
-        "type": "object",
-        "description": "An interface which allows access to a Chrome browser setting.",
-        "functions": [
-          {
-            "name": "get",
-            "type": "function",
-            "description": "Gets the value of a setting.",
-            "parameters": [
-              {
-                "name": "details",
-                "type": "object",
-                "description": "What setting to consider.",
-                "properties": {
-                  "incognito": {
-                    "type": "boolean",
-                    "optional": true,
-                    "description": "Whether to return the setting that applies to the incognito session (default false)."
-                  }
-                }
-              }
-            ]
-          }
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/test/functions_on_types_unittest.cc b/tools/json_schema_compiler/test/functions_on_types_unittest.cc
deleted file mode 100644
index 86ce492..0000000
--- a/tools/json_schema_compiler/test/functions_on_types_unittest.cc
+++ /dev/null
@@ -1,71 +0,0 @@
-// 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.
-
-#include "base/values.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "tools/json_schema_compiler/test/functions_on_types.h"
-
-using namespace test::api::functions_on_types;
-
-TEST(JsonSchemaCompilerFunctionsOnTypesTest, StorageAreaGetParamsCreate) {
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    scoped_ptr<StorageArea::Get::Params> params(
-        StorageArea::Get::Params::Create(*params_value));
-    ASSERT_TRUE(params);
-    EXPECT_FALSE(params->keys);
-  }
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    params_value->Append(new base::FundamentalValue(9));
-    scoped_ptr<StorageArea::Get::Params> params(
-        StorageArea::Get::Params::Create(*params_value));
-    EXPECT_FALSE(params);
-  }
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    params_value->Append(new base::StringValue("test"));
-    scoped_ptr<StorageArea::Get::Params> params(
-        StorageArea::Get::Params::Create(*params_value));
-    ASSERT_TRUE(params);
-    ASSERT_TRUE(params->keys);
-    EXPECT_EQ("test", *params->keys->as_string);
-  }
-  {
-    scoped_ptr<base::DictionaryValue> keys_object_value(
-        new base::DictionaryValue());
-    keys_object_value->SetInteger("integer", 5);
-    keys_object_value->SetString("string", "string");
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    params_value->Append(keys_object_value->DeepCopy());
-    scoped_ptr<StorageArea::Get::Params> params(
-        StorageArea::Get::Params::Create(*params_value));
-    ASSERT_TRUE(params);
-    ASSERT_TRUE(params->keys);
-    EXPECT_TRUE(keys_object_value->Equals(
-        &params->keys->as_object->additional_properties));
-  }
-}
-
-TEST(JsonSchemaCompilerFunctionsOnTypesTest, StorageAreaGetResultCreate) {
-  StorageArea::Get::Results::Items items;
-  items.additional_properties.SetDouble("asdf", 0.1);
-  items.additional_properties.SetString("sdfg", "zxcv");
-  scoped_ptr<base::ListValue> results =
-      StorageArea::Get::Results::Create(items);
-  base::DictionaryValue* item_result = NULL;
-  ASSERT_TRUE(results->GetDictionary(0, &item_result));
-  EXPECT_TRUE(item_result->Equals(&items.additional_properties));
-}
-
-TEST(JsonSchemaCompilerFunctionsOnTypesTest, ChromeSettingGetParamsCreate) {
-  scoped_ptr<base::DictionaryValue> details_value(new base::DictionaryValue());
-  details_value->SetBoolean("incognito", true);
-  scoped_ptr<base::ListValue> params_value(new base::ListValue());
-  params_value->Append(details_value.release());
-  scoped_ptr<ChromeSetting::Get::Params> params(
-      ChromeSetting::Get::Params::Create(*params_value));
-  EXPECT_TRUE(params.get());
-  EXPECT_TRUE(*params->details.incognito);
-}
diff --git a/tools/json_schema_compiler/test/idl_basics.idl b/tools/json_schema_compiler/test/idl_basics.idl
deleted file mode 100644
index 463574f..0000000
--- a/tools/json_schema_compiler/test/idl_basics.idl
+++ /dev/null
@@ -1,106 +0,0 @@
-// 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.
-
-// Tests a variety of basic API definition features.
-
-[internal] namespace idl_basics {
-  // Enum description
-  enum EnumType {
-    // comment1
-    name1,
-    name2
-  };
-
-  [nodoc] enum EnumTypeWithNoDoc {
-    name1,
-    name2
-  };
-
-  dictionary MyType1 {
-    // This comment tests "double-quotes".
-    [legalValues=(1,2)] long x;
-    DOMString y;
-    DOMString z;
-    DOMString a;
-    DOMString b;
-    DOMString c;
-  };
-
-  dictionary MyType2 {
-    DOMString x;
-  };
-
-  callback Callback1 = void();
-  callback Callback2 = void(long x);
-  callback Callback3 = void(MyType1 arg);
-  callback Callback4 = void(MyType2[] arg);
-  callback Callback5 = void(EnumType type);
-  // A comment on a callback.
-  // |x|: A parameter.
-  callback Callback6 = void(long x);
-  // |x|: Just a parameter comment, with no comment on the callback.
-  callback Callback7 = void(long x);
-
-  interface Functions {
-    static void function1();
-    static void function2(long x);
-    // This comment should appear in the documentation,
-    // despite occupying multiple lines.
-    //
-    // |arg|: So should this comment
-    // about the argument.
-    // <em>HTML</em> is fine too.
-    static void function3(MyType1 arg);
-
-    // This tests if "double-quotes" are escaped correctly.
-    //
-    // It also tests a comment with two newlines.
-    static void function4(Callback1 cb);
-    static void function5(Callback2 cb);
-    static void function6(Callback3 cb);
-
-    static void function7(optional long arg);
-    static void function8(long arg1, optional DOMString arg2);
-    static void function9(optional MyType1 arg);
-
-    static void function10(long x, long[] y);
-    static void function11(MyType1[] arg);
-
-    static void function12(Callback4 cb);
-
-    static void function13(EnumType type, Callback5 cb);
-    static void function14(EnumType[] types);
-
-    // "switch" is a reserved word and should cause a C++ compile error if we
-    // emit code for this declaration.
-    [nocompile] static void function15(long switch);
-
-    static void function16(Callback6 cb);
-    static void function17(Callback7 cb);
-    // |cb|: Override callback comment.
-    static void function18(Callback7 cb);
-
-    static void function20(idl_other_namespace.SomeType value);
-    static void function21(idl_other_namespace.SomeType[] values);
-    static void function22(
-        idl_other_namespace.sub_namespace.AnotherType value);
-    static void function23(
-        idl_other_namespace.sub_namespace.AnotherType[] values);
-
-    static long function24();
-    static MyType1 function25();
-    static MyType1[] function26();
-    static EnumType function27();
-    static EnumType[] function28();
-    static idl_other_namespace.SomeType function29();
-    static idl_other_namespace.SomeType[] function30();
-  };
-
-  interface Events {
-    static void onFoo1();
-    static void onFoo2(long x);
-    static void onFoo2(MyType1 arg);
-    static void onFoo3(EnumType type);
-  };
-};
diff --git a/tools/json_schema_compiler/test/idl_function_types.idl b/tools/json_schema_compiler/test/idl_function_types.idl
deleted file mode 100644
index 96bff43..0000000
--- a/tools/json_schema_compiler/test/idl_function_types.idl
+++ /dev/null
@@ -1,18 +0,0 @@
-// 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.
-
-// Tests function and callback types in various places in IDL.
-
-namespace idl_function_types {
-  callback MyCallback = void(long x);
-  callback MyUnionCallback = void ((long or DOMString) x);
-  callback MyOptionalUnionCallback = void (optional (long or DOMString) x);
-
-  interface Functions {
-    static void whatever(MyCallback[] callbacks);
-    static void blah(MyUnionCallback callback);
-    static void badabish(MyOptionalUnionCallback callback);
-    static void union_params((long or DOMString) x);
-  };
-};
diff --git a/tools/json_schema_compiler/test/idl_namespace_all_platforms.idl b/tools/json_schema_compiler/test/idl_namespace_all_platforms.idl
deleted file mode 100644
index 7ffd84a..0000000
--- a/tools/json_schema_compiler/test/idl_namespace_all_platforms.idl
+++ /dev/null
@@ -1,10 +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.
-
-// Tests a variety of basic API definition features.
-
-[platforms=("chromeos", "chromeos_touch", "linux", "mac", "win")]
-namespace idl_namespace_all_platforms {
-
-};
diff --git a/tools/json_schema_compiler/test/idl_namespace_chromeos.idl b/tools/json_schema_compiler/test/idl_namespace_chromeos.idl
deleted file mode 100644
index ad748ff..0000000
--- a/tools/json_schema_compiler/test/idl_namespace_chromeos.idl
+++ /dev/null
@@ -1,10 +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.
-
-// Tests the case of a namespace with chromeos platforms.
-
-[platforms=("chromeos")]
-namespace idl_namespace_chromeos {
-
-};
diff --git a/tools/json_schema_compiler/test/idl_namespace_non_specific_platforms.idl b/tools/json_schema_compiler/test/idl_namespace_non_specific_platforms.idl
deleted file mode 100644
index cff64f8..0000000
--- a/tools/json_schema_compiler/test/idl_namespace_non_specific_platforms.idl
+++ /dev/null
@@ -1,9 +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.
-
-// Tests the case of a namespace with non specific platforms.
-
-namespace idl_namespace_non_specific_platforms {
-
-};
diff --git a/tools/json_schema_compiler/test/idl_namespace_specific_implement.idl b/tools/json_schema_compiler/test/idl_namespace_specific_implement.idl
deleted file mode 100644
index 99b65ac..0000000
--- a/tools/json_schema_compiler/test/idl_namespace_specific_implement.idl
+++ /dev/null
@@ -1,10 +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.
-
-// Tests the case of a namespace with specific implemented file.
-
-[implemented_in="idl_namespace_specific_implement.idl"]
-namespace idl_namespace_specific_implement {
-
-};
diff --git a/tools/json_schema_compiler/test/idl_namespace_specific_implement_chromeos.idl b/tools/json_schema_compiler/test/idl_namespace_specific_implement_chromeos.idl
deleted file mode 100644
index 619e073..0000000
--- a/tools/json_schema_compiler/test/idl_namespace_specific_implement_chromeos.idl
+++ /dev/null
@@ -1,11 +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.
-
-// Tests the case of a namespace with specific implemented file on chromeos.
-
-[platforms=("chromeos"),
- implemented_in="idl_namespace_specific_implement_chromeos.idl"]
-namespace idl_namespace_specific_implement_chromeos {
-
-};
diff --git a/tools/json_schema_compiler/test/idl_object_types.idl b/tools/json_schema_compiler/test/idl_object_types.idl
deleted file mode 100644
index ebf9f38..0000000
--- a/tools/json_schema_compiler/test/idl_object_types.idl
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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.
-
-// Tests 'object' types in various places in IDL.
-
-namespace idl_object_types {
-  dictionary FooType {
-    long x;
-    object y;
-    [instanceOf=Window]object z;
-  };
-
-  dictionary BarType {
-    any x;
-  };
-
-  dictionary BazType {
-    long? x;
-    FooType? foo;
-  };
-
-  dictionary UnionType {
-    (long or FooType)? x;
-    (DOMString or object) y;
-    ([instanceOf=ImageData]object or long) z;
-  };
-
-  dictionary ModifiedUnionType {
-    [nodoc] (long or DOMString) x;
-  };
-
-  interface Functions {
-    static void objectFunction1([instanceOf=ImageData]object icon);
-    static void objectFunction2(any some_arg);
-  };
-};
diff --git a/tools/json_schema_compiler/test/idl_other_namespace.idl b/tools/json_schema_compiler/test/idl_other_namespace.idl
deleted file mode 100644
index 9aa3fa0..0000000
--- a/tools/json_schema_compiler/test/idl_other_namespace.idl
+++ /dev/null
@@ -1,12 +0,0 @@
-// 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.
-
-// Provides types for testing scoped types included in idl_basics.idl.
-
-namespace idl_other_namespace {
-  enum SomeType {
-    hello,
-    world
-  };
-};
diff --git a/tools/json_schema_compiler/test/idl_other_namespace_sub_namespace.idl b/tools/json_schema_compiler/test/idl_other_namespace_sub_namespace.idl
deleted file mode 100644
index 0d6a2cc..0000000
--- a/tools/json_schema_compiler/test/idl_other_namespace_sub_namespace.idl
+++ /dev/null
@@ -1,12 +0,0 @@
-// 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.
-
-// Provides types for testing scoped types included in idl_basics.idl.
-
-namespace idl_other_namespace.sub_namespace {
-  enum AnotherType {
-    hello,
-    world
-  };
-};
diff --git a/tools/json_schema_compiler/test/idl_reserved_words.idl b/tools/json_schema_compiler/test/idl_reserved_words.idl
deleted file mode 100644
index 411973e..0000000
--- a/tools/json_schema_compiler/test/idl_reserved_words.idl
+++ /dev/null
@@ -1,27 +0,0 @@
-// 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.
-
-// Tests 'reserved words' in various places in IDL.
-
-namespace reserved_words {
-
-  enum Foo { _float, _DOMString };
-
-  enum _enum {
-    _callback,
-    _namespace
-  };
-
-  dictionary _dictionary {
-    long _long;
-  };
-
-  dictionary MyType {
-    DOMString _interface;
-  };
-
-  interface Functions {
-    static void _static(Foo foo, _enum e);
-  };
-};
diff --git a/tools/json_schema_compiler/test/idl_schemas_unittest.cc b/tools/json_schema_compiler/test/idl_schemas_unittest.cc
deleted file mode 100644
index 1817afb..0000000
--- a/tools/json_schema_compiler/test/idl_schemas_unittest.cc
+++ /dev/null
@@ -1,199 +0,0 @@
-// 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.
-
-#include "base/values.h"
-#include "tools/json_schema_compiler/test/idl_basics.h"
-#include "tools/json_schema_compiler/test/idl_object_types.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-using test::api::idl_basics::MyType1;
-using test::api::idl_object_types::BarType;
-using test::api::idl_object_types::FooType;
-
-namespace Function2 = test::api::idl_basics::Function2;
-namespace Function3 = test::api::idl_basics::Function3;
-namespace Function4 = test::api::idl_basics::Function4;
-namespace Function5 = test::api::idl_basics::Function5;
-namespace Function6 = test::api::idl_basics::Function6;
-namespace Function7 = test::api::idl_basics::Function7;
-namespace Function8 = test::api::idl_basics::Function8;
-namespace Function9 = test::api::idl_basics::Function9;
-namespace Function10 = test::api::idl_basics::Function10;
-namespace Function11 = test::api::idl_basics::Function11;
-namespace ObjectFunction1 = test::api::idl_object_types::ObjectFunction1;
-
-TEST(IdlCompiler, Basics) {
-  // Test MyType1.
-  MyType1 a;
-  a.x = 5;
-  a.y = std::string("foo");
-  scoped_ptr<base::DictionaryValue> serialized = a.ToValue();
-  MyType1 b;
-  EXPECT_TRUE(MyType1::Populate(*serialized.get(), &b));
-  EXPECT_EQ(a.x, b.x);
-  EXPECT_EQ(a.y, b.y);
-
-  // Test Function2, which takes an integer parameter.
-  base::ListValue list;
-  list.Append(new base::FundamentalValue(5));
-  scoped_ptr<Function2::Params> f2_params = Function2::Params::Create(list);
-  EXPECT_EQ(5, f2_params->x);
-
-  // Test Function3, which takes a MyType1 parameter.
-  list.Clear();
-  base::DictionaryValue* tmp = new base::DictionaryValue();
-  tmp->SetInteger("x", 17);
-  tmp->SetString("y", "hello");
-  tmp->SetString("z", "zstring");
-  tmp->SetString("a", "astring");
-  tmp->SetString("b", "bstring");
-  tmp->SetString("c", "cstring");
-  list.Append(tmp);
-  scoped_ptr<Function3::Params> f3_params = Function3::Params::Create(list);
-  EXPECT_EQ(17, f3_params->arg.x);
-  EXPECT_EQ("hello", f3_params->arg.y);
-
-  // Test functions that take a callback function as a parameter, with varying
-  // callback signatures.
-  scoped_ptr<base::ListValue> f4_results = Function4::Results::Create();
-  base::ListValue expected;
-  EXPECT_TRUE(f4_results->Equals(&expected));
-
-  scoped_ptr<base::ListValue> f5_results(Function5::Results::Create(13));
-  base::Value* f5_result_int = NULL;
-  ASSERT_TRUE(f5_results->Get(0, &f5_result_int));
-  EXPECT_TRUE(f5_result_int->IsType(base::Value::TYPE_INTEGER));
-
-  scoped_ptr<base::ListValue> f6_results(Function6::Results::Create(a));
-  base::Value* f6_result_dict = NULL;
-  ASSERT_TRUE(f6_results->Get(0, &f6_result_dict));
-  MyType1 c;
-  EXPECT_TRUE(MyType1::Populate(*f6_result_dict, &c));
-  EXPECT_EQ(a.x, c.x);
-  EXPECT_EQ(a.y, c.y);
-}
-
-TEST(IdlCompiler, OptionalArguments) {
-  // Test a function that takes one optional argument, both without and with
-  // that argument.
-  base::ListValue list;
-  scoped_ptr<Function7::Params> f7_params = Function7::Params::Create(list);
-  EXPECT_EQ(NULL, f7_params->arg.get());
-  list.Append(new base::FundamentalValue(7));
-  f7_params = Function7::Params::Create(list);
-  EXPECT_EQ(7, *(f7_params->arg));
-
-  // Similar to above, but a function with one required and one optional
-  // argument.
-  list.Clear();
-  list.Append(new base::FundamentalValue(8));
-  scoped_ptr<Function8::Params> f8_params = Function8::Params::Create(list);
-  EXPECT_EQ(8, f8_params->arg1);
-  EXPECT_EQ(NULL, f8_params->arg2.get());
-  list.Append(new base::StringValue("foo"));
-  f8_params = Function8::Params::Create(list);
-  EXPECT_EQ(8, f8_params->arg1);
-  EXPECT_EQ("foo", *(f8_params->arg2));
-
-  // Test a function with an optional argument of custom type.
-  list.Clear();
-  scoped_ptr<Function9::Params> f9_params = Function9::Params::Create(list);
-  EXPECT_EQ(NULL, f9_params->arg.get());
-  list.Clear();
-  base::DictionaryValue* tmp = new base::DictionaryValue();
-  tmp->SetInteger("x", 17);
-  tmp->SetString("y", "hello");
-  tmp->SetString("z", "zstring");
-  tmp->SetString("a", "astring");
-  tmp->SetString("b", "bstring");
-  tmp->SetString("c", "cstring");
-  list.Append(tmp);
-  f9_params = Function9::Params::Create(list);
-  ASSERT_TRUE(f9_params->arg.get() != NULL);
-  MyType1* t1 = f9_params->arg.get();
-  EXPECT_EQ(17, t1->x);
-  EXPECT_EQ("hello", t1->y);
-}
-
-TEST(IdlCompiler, ArrayTypes) {
-  // Tests of a function that takes an integer and an array of integers. First
-  // use an empty array.
-  base::ListValue list;
-  list.Append(new base::FundamentalValue(33));
-  list.Append(new base::ListValue);
-  scoped_ptr<Function10::Params> f10_params = Function10::Params::Create(list);
-  ASSERT_TRUE(f10_params != NULL);
-  EXPECT_EQ(33, f10_params->x);
-  EXPECT_TRUE(f10_params->y.empty());
-
-  // Same function, but this time with 2 values in the array.
-  list.Clear();
-  list.Append(new base::FundamentalValue(33));
-  base::ListValue* sublist = new base::ListValue;
-  sublist->Append(new base::FundamentalValue(34));
-  sublist->Append(new base::FundamentalValue(35));
-  list.Append(sublist);
-  f10_params = Function10::Params::Create(list);
-  ASSERT_TRUE(f10_params != NULL);
-  EXPECT_EQ(33, f10_params->x);
-  ASSERT_EQ(2u, f10_params->y.size());
-  EXPECT_EQ(34, f10_params->y[0]);
-  EXPECT_EQ(35, f10_params->y[1]);
-
-  // Now test a function which takes an array of a defined type.
-  list.Clear();
-  MyType1 a;
-  MyType1 b;
-  a.x = 5;
-  b.x = 6;
-  a.y = std::string("foo");
-  b.y = std::string("bar");
-  base::ListValue* sublist2 = new base::ListValue;
-  sublist2->Append(a.ToValue().release());
-  sublist2->Append(b.ToValue().release());
-  list.Append(sublist2);
-  scoped_ptr<Function11::Params> f11_params = Function11::Params::Create(list);
-  ASSERT_TRUE(f11_params != NULL);
-  ASSERT_EQ(2u, f11_params->arg.size());
-  EXPECT_EQ(5, f11_params->arg[0]->x);
-  EXPECT_EQ("foo", f11_params->arg[0]->y);
-  EXPECT_EQ(6, f11_params->arg[1]->x);
-  EXPECT_EQ("bar", f11_params->arg[1]->y);
-}
-
-TEST(IdlCompiler, ObjectTypes) {
-  // Test the FooType type.
-  FooType f1;
-  f1.x = 3;
-  scoped_ptr<base::DictionaryValue> serialized_foo = f1.ToValue();
-  FooType f2;
-  EXPECT_TRUE(FooType::Populate(*serialized_foo.get(), &f2));
-  EXPECT_EQ(f1.x, f2.x);
-
-  // Test the BarType type.
-  BarType b1;
-  b1.x.reset(new base::FundamentalValue(7));
-  scoped_ptr<base::DictionaryValue> serialized_bar = b1.ToValue();
-  BarType b2;
-  EXPECT_TRUE(BarType::Populate(*serialized_bar.get(), &b2));
-  int tmp_int = 0;
-  EXPECT_TRUE(b2.x->GetAsInteger(&tmp_int));
-  EXPECT_EQ(7, tmp_int);
-
-  // Test the params to the ObjectFunction1 function.
-  scoped_ptr<base::DictionaryValue> icon_props(new base::DictionaryValue());
-  icon_props->SetString("hello", "world");
-  ObjectFunction1::Params::Icon icon;
-  EXPECT_TRUE(ObjectFunction1::Params::Icon::Populate(*(icon_props.get()),
-                                                      &icon));
-  base::ListValue list;
-  list.Append(icon_props.release());
-  scoped_ptr<ObjectFunction1::Params> params =
-    ObjectFunction1::Params::Create(list);
-  ASSERT_TRUE(params.get() != NULL);
-  std::string tmp;
-  EXPECT_TRUE(params->icon.additional_properties.GetString("hello", &tmp));
-  EXPECT_EQ("world", tmp);
-}
diff --git a/tools/json_schema_compiler/test/json_schema_compiler_tests.gyp b/tools/json_schema_compiler/test/json_schema_compiler_tests.gyp
deleted file mode 100644
index 7921f87..0000000
--- a/tools/json_schema_compiler/test/json_schema_compiler_tests.gyp
+++ /dev/null
@@ -1,46 +0,0 @@
-# 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.
-
-{
-  'targets': [
-    {
-      'target_name': 'json_schema_compiler_tests',
-      'type': 'static_library',
-      'variables': {
-        'chromium_code': 1,
-        'schema_files': [
-          'additional_properties.json',
-          'any.json',
-          'arrays.json',
-          'callbacks.json',
-          'choices.json',
-          'crossref.json',
-          'enums.json',
-          'functions_as_parameters.json',
-          'functions_on_types.json',
-          'idl_basics.idl',
-          'idl_other_namespace.idl',
-          'idl_other_namespace_sub_namespace.idl',
-          'idl_object_types.idl',
-          'objects.json',
-          'simple_api.json',
-          'error_generation.json'
-        ],
-        'cc_dir': 'tools/json_schema_compiler/test',
-        'root_namespace': 'test::api::%(namespace)s',
-      },
-      'inputs': [
-        '<@(schema_files)',
-      ],
-      'sources': [
-        '<@(schema_files)',
-        'test_util.cc',
-        'test_util.h',
-      ],
-      'includes': ['../../../build/json_schema_compile.gypi'],
-      # TODO(jschuh): crbug.com/167187 fix size_t to int truncations.
-      'msvs_disabled_warnings': [4267, ],
-    },
-  ],
-}
diff --git a/tools/json_schema_compiler/test/json_schema_test.json b/tools/json_schema_compiler/test/json_schema_test.json
deleted file mode 100644
index b3b24e9..0000000
--- a/tools/json_schema_compiler/test/json_schema_test.json
+++ /dev/null
@@ -1,106 +0,0 @@
-[
-  {
-    "namespace": "compile",
-    "description": "The compile API.",
-    "functions": [],
-    "types":     {}
-  },
-
-  {
-    "namespace": "nocompile",
-    "description": "The nocompile API.",
-    "nocompile": true,
-    "functions": [],
-    "types":     {}
-  },
-
-  {
-    "namespace": "functions",
-    "description": "The functions API.",
-    "functions": [
-      {
-        "id": "one",
-        "nocompile": true
-      },
-      {
-        "id": "two"
-      },
-      {
-        "id": "three",
-        "nocompile": true
-      },
-      {
-        "id": "four"
-      }
-    ],
-
-    "types": {
-      "one": { "key": "value" }
-    }
-  },
-
-  {
-    "namespace": "types",
-    "description": "The types API.",
-    "functions": [
-      { "id": "one" }
-    ],
-    "types": {
-      "one": {
-        "key": "value",
-        "nocompile": true
-      },
-      "two": {
-        "key": "value"
-      },
-      "three": {
-        "key": "value",
-        "nocompile": true
-      },
-      "four": {
-        "key": "value"
-      }
-    }
-  },
-
-  {
-    "namespace": "nested",
-    "description": "The nested API.",
-    "properties": {
-      "sync": {
-        "functions": [
-          {
-            "id": "one",
-            "nocompile": true
-          },
-          {
-            "id": "two"
-          },
-          {
-            "id": "three",
-            "nocompile": true
-          },
-          {
-            "id": "four"
-          }
-        ],
-        "types": {
-          "one": {
-            "key": "value",
-            "nocompile": true
-          },
-          "two": {
-            "key": "value"
-          },
-          "three": {
-            "key": "value",
-            "nocompile": true
-          },
-          "four": {
-            "key": "value"
-          }
-        }
-      }
-    }
-  }
-]
diff --git a/tools/json_schema_compiler/test/objects.json b/tools/json_schema_compiler/test/objects.json
deleted file mode 100644
index e76e229..0000000
--- a/tools/json_schema_compiler/test/objects.json
+++ /dev/null
@@ -1,140 +0,0 @@
-[
-  {
-    "namespace": "objects",
-    "description": "The objects API.",
-    "types": [],
-    "functions": [
-      {
-        "name": "objectParam",
-        "type": "function",
-        "description": "Takes an object.",
-        "parameters": [
-          {
-            "name": "info",
-            "type": "object",
-            "properties": {
-              "strings": {
-                "type": "array",
-                "items": {"type": "string"}
-              },
-              "integer": {
-                "type": "integer"
-              },
-              "boolean": {
-                "type": "boolean"
-              }
-            }
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "returnsObject",
-        "description": "Returns an object.",
-        "type": "function",
-        "parameters": [
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-              {
-                "name": "info",
-                "type": "object",
-                "properties": {
-                  "state": {
-                    "type": "string",
-                    "enum": ["foo", "bar", "baz"]
-                  }
-                }
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "returnsTwoObjects",
-        "description": "Return two objects.",
-        "type": "function",
-        "parameters": [
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-              {
-                "name": "firstInfo",
-                "type": "object",
-                "properties": {
-                  "state": {
-                    "type": "string",
-                    "enum": ["foo", "bar", "baz"]
-                  }
-                }
-              },
-              {
-                "name": "secondInfo",
-                "type": "object",
-                "properties": {
-                  "state": {
-                    "type": "string",
-                    "enum": ["spam", "ham", "eggs"]
-                  }
-                }
-              }
-            ]
-          }
-        ]
-      }
-    ],
-    "events": [
-      {
-        "name": "onObjectFired",
-        "type": "function",
-        "description": "Fired when an object is ready.",
-        "parameters": [
-          {
-            "name": "someObject",
-            "type": "object",
-            "properties": {
-              "state": {
-                "type": "string",
-                "enum": ["foo", "bar", "baz"]
-              }
-            }
-          }
-        ]
-      },
-      {
-        "name": "onTwoObjectsFired",
-        "type": "function",
-        "description": "Fired when two objects are ready.",
-        "parameters": [
-          {
-            "name": "firstObject",
-            "type": "object",
-            "properties": {
-              "state": {
-                "type": "string",
-                "enum": ["foo", "bar", "baz"]
-              }
-            }
-          },
-          {
-            "name": "secondObject",
-            "type": "object",
-            "properties": {
-              "state": {
-                "type": "string",
-                "enum": ["spam", "ham", "eggs"]
-              }
-            }
-          }
-        ]
-      }
-    ]
-  }
-]
-
diff --git a/tools/json_schema_compiler/test/objects_unittest.cc b/tools/json_schema_compiler/test/objects_unittest.cc
deleted file mode 100644
index 6dc2c45..0000000
--- a/tools/json_schema_compiler/test/objects_unittest.cc
+++ /dev/null
@@ -1,71 +0,0 @@
-// 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.
-
-#include "tools/json_schema_compiler/test/objects.h"
-
-#include "base/json/json_writer.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using namespace test::api::objects;
-
-TEST(JsonSchemaCompilerObjectsTest, ObjectParamParamsCreate) {
-  {
-    scoped_ptr<base::ListValue> strings(new base::ListValue());
-    strings->Append(new base::StringValue("one"));
-    strings->Append(new base::StringValue("two"));
-    scoped_ptr<base::DictionaryValue> info_value(new base::DictionaryValue());
-    info_value->Set("strings", strings.release());
-    info_value->Set("integer", new base::FundamentalValue(5));
-    info_value->Set("boolean", new base::FundamentalValue(true));
-
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    params_value->Append(info_value.release());
-    scoped_ptr<ObjectParam::Params> params(
-        ObjectParam::Params::Create(*params_value));
-    EXPECT_TRUE(params.get());
-    EXPECT_EQ((size_t) 2, params->info.strings.size());
-    EXPECT_EQ("one", params->info.strings[0]);
-    EXPECT_EQ("two", params->info.strings[1]);
-    EXPECT_EQ(5, params->info.integer);
-    EXPECT_TRUE(params->info.boolean);
-  }
-  {
-    scoped_ptr<base::ListValue> strings(new base::ListValue());
-    strings->Append(new base::StringValue("one"));
-    strings->Append(new base::StringValue("two"));
-    scoped_ptr<base::DictionaryValue> info_value(new base::DictionaryValue());
-    info_value->Set("strings", strings.release());
-    info_value->Set("integer", new base::FundamentalValue(5));
-
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    params_value->Append(info_value.release());
-    scoped_ptr<ObjectParam::Params> params(
-        ObjectParam::Params::Create(*params_value));
-    EXPECT_FALSE(params.get());
-  }
-}
-
-TEST(JsonSchemaCompilerObjectsTest, ReturnsObjectResultCreate) {
-  ReturnsObject::Results::Info info;
-  info.state = ReturnsObject::Results::Info::STATE_FOO;
-  scoped_ptr<base::ListValue> results = ReturnsObject::Results::Create(info);
-
-  base::DictionaryValue expected;
-  expected.SetString("state", "foo");
-  base::DictionaryValue* result = NULL;
-  ASSERT_TRUE(results->GetDictionary(0, &result));
-  ASSERT_TRUE(result->Equals(&expected));
-}
-
-TEST(JsonSchemaCompilerObjectsTest, OnObjectFiredCreate) {
-  OnObjectFired::SomeObject object;
-  object.state = OnObjectFired::SomeObject::STATE_BAR;
-  scoped_ptr<base::ListValue> results(OnObjectFired::Create(object));
-
-  base::DictionaryValue expected;
-  expected.SetString("state", "bar");
-  base::DictionaryValue* result = NULL;
-  ASSERT_TRUE(results->GetDictionary(0, &result));
-  ASSERT_TRUE(result->Equals(&expected));
-}
diff --git a/tools/json_schema_compiler/test/permissions.json b/tools/json_schema_compiler/test/permissions.json
deleted file mode 100644
index df97441..0000000
--- a/tools/json_schema_compiler/test/permissions.json
+++ /dev/null
@@ -1,140 +0,0 @@
-[
-  {
-    "namespace": "permissions",
-    "description": "A test API for the json_schema_compiler.",
-    "types": [
-      {
-        "id": "Permissions",
-        "type": "object",
-        "properties": {
-          "permissions": {
-            "type": "array",
-            "items": {"type": "string"},
-            "optional": true,
-            "description": "List of named permissions (does not include hosts or origins)."
-          },
-          "origins": {
-            "type": "array",
-            "items": {"type": "string"},
-            "optional": true,
-            "description": "List of origin permissions."
-          }
-        }
-      }
-    ],
-    "events": [
-      {
-        "name": "onAdded",
-        "type": "function",
-        "description": "Fired when the extension acquires new permissions.",
-        "parameters": [
-          {
-            "$ref": "Permissions",
-            "name": "permissions",
-            "description": "The newly acquired permissions."
-          }
-        ]
-      },
-      {
-        "name": "onRemoved",
-        "type": "function",
-        "description": "Fired when access to permissions has been removed from the extension.",
-        "parameters": [
-          {
-            "$ref": "Permissions",
-            "name": "permissions",
-            "description": "The permissions that have been removed."
-          }
-        ]
-      }
-     ],
-    "functions": [
-      {
-        "name": "getAll",
-        "type": "function",
-        "description": "Gets the extension's current set of permissions.",
-        "parameters": [
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-               {
-                "name": "permissions",
-                "$ref": "Permissions",
-                "description": "The extension's active permissions."
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "contains",
-        "type": "function",
-        "description": "Checks if the extension has the specified permissions.",
-        "parameters": [
-          {
-            "name": "permissions",
-            "$ref": "Permissions"
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-              {
-                "name": "result",
-                "type": "boolean",
-                "description": "True if the extension has the specified permissions."
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "request",
-        "type": "function",
-        "description": "Requests access to the specified permissions. These permissions must be defined in the optional_permissions field of the manifest. If there are any problems requesting the permissions, <a href='extension.html#property-lastError'>chrome.runtime.lastError</a> will be set.",
-        "parameters": [
-          {
-            "name": "permissions",
-            "$ref": "Permissions"
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "granted",
-                "type": "boolean",
-                "description": "True if the user granted the specified permissions."
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "remove",
-        "type": "function",
-        "description": "Removes access to the specified permissions. If there are any problems removing the permissions, <a href='extension.html#property-lastError'>chrome.runtime.lastError</a> will be set.",
-        "parameters": [
-          {
-            "name": "permissions",
-            "$ref": "Permissions"
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "removed",
-                "type": "boolean",
-                "description": "True if the permissions were removed."
-              }
-            ]
-          }
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/test/simple_api.json b/tools/json_schema_compiler/test/simple_api.json
deleted file mode 100644
index 9ab5403..0000000
--- a/tools/json_schema_compiler/test/simple_api.json
+++ /dev/null
@@ -1,163 +0,0 @@
-[
-  {
-    "namespace": "simple_api",
-    "description": "This is a simple API.",
-    "types": [
-      {
-        "id": "TestType",
-        "type": "object",
-        "properties": {
-          "string": {
-            "type": "string",
-            "description": "Some string."
-          },
-          "boolean": {
-            "type": "boolean",
-            "description": "Some boolean."
-          },
-          "number": {
-            "type": "number",
-            "description": "Some double."
-          },
-          "integer": {
-            "type": "integer",
-            "description": "Some integer."
-          }
-        }
-      }
-    ],
-    "functions": [
-      {
-        "name": "incrementInteger",
-        "type": "function",
-        "description": "Increments the given integer.",
-        "parameters": [
-          {
-            "name": "num",
-            "type": "integer"
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-              {
-                "name": "result",
-                "type": "integer",
-                "description": "The incremented value."
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "optionalString",
-        "type": "function",
-        "description": "Takes a string. Or not.",
-        "parameters": [
-          {
-            "name": "str",
-            "type": "string",
-            "optional": true
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "optionalBeforeRequired",
-        "type": "function",
-        "description": "Takes an optional parameter followed by a required one.",
-        "parameters": [
-          {
-            "name": "first",
-            "type": "string",
-            "optional": true
-          },
-          {
-            "name": "second",
-            "type": "string"
-          },
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "optionalCallbackParams",
-        "type": "function",
-        "description": "Gives back a string. Or not.",
-        "parameters": [
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-              {
-                "name": "result",
-                "$ref": "TestType",
-                "description": "True if the extension has the specified permissions."
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "getTestType",
-        "type": "function",
-        "description": "Return a TestType.",
-        "parameters": [
-          {
-            "name": "callback",
-            "type": "function",
-            "parameters": [
-              {
-                "name": "result",
-                "$ref": "TestType",
-                "description": "A TestType."
-              }
-            ]
-          }
-        ]
-      }
-    ],
-    "events": [
-      {
-        "name": "onIntegerFired",
-        "type": "function",
-        "description": "Fired when an integer is ready.",
-        "parameters": [
-          {
-            "name": "someInteger",
-            "type": "integer"
-          }
-        ]
-      },
-      {
-        "name": "onStringFired",
-        "type": "function",
-        "description": "Fired when a string is ready.",
-        "parameters": [
-          {
-            "name": "someString",
-            "type": "string"
-          }
-        ]
-      },
-      {
-        "name": "onTestTypeFired",
-        "type": "function",
-        "description": "Fired when a TestType is ready.",
-        "parameters": [
-          {
-            "name": "someTestType",
-            "$ref": "TestType"
-          }
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/test/simple_api_unittest.cc b/tools/json_schema_compiler/test/simple_api_unittest.cc
deleted file mode 100644
index f100b81..0000000
--- a/tools/json_schema_compiler/test/simple_api_unittest.cc
+++ /dev/null
@@ -1,182 +0,0 @@
-// 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.
-
-#include "tools/json_schema_compiler/test/simple_api.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-using namespace test::api::simple_api;
-
-namespace {
-
-static scoped_ptr<base::DictionaryValue> CreateTestTypeDictionary() {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  value->SetWithoutPathExpansion("number", new base::FundamentalValue(1.1));
-  value->SetWithoutPathExpansion("integer", new base::FundamentalValue(4));
-  value->SetWithoutPathExpansion("string", new base::StringValue("bling"));
-  value->SetWithoutPathExpansion("boolean", new base::FundamentalValue(true));
-  return value.Pass();
-}
-
-}  // namespace
-
-TEST(JsonSchemaCompilerSimpleTest, IncrementIntegerResultCreate) {
-  scoped_ptr<base::ListValue> results = IncrementInteger::Results::Create(5);
-  base::ListValue expected;
-  expected.Append(new base::FundamentalValue(5));
-  EXPECT_TRUE(results->Equals(&expected));
-}
-
-TEST(JsonSchemaCompilerSimpleTest, IncrementIntegerParamsCreate) {
-  scoped_ptr<base::ListValue> params_value(new base::ListValue());
-  params_value->Append(new base::FundamentalValue(6));
-  scoped_ptr<IncrementInteger::Params> params(
-      IncrementInteger::Params::Create(*params_value));
-  EXPECT_TRUE(params.get());
-  EXPECT_EQ(6, params->num);
-}
-
-TEST(JsonSchemaCompilerSimpleTest, NumberOfParams) {
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    params_value->Append(new base::StringValue("text"));
-    params_value->Append(new base::StringValue("text"));
-    scoped_ptr<OptionalString::Params> params(
-        OptionalString::Params::Create(*params_value));
-    EXPECT_FALSE(params.get());
-  }
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    scoped_ptr<IncrementInteger::Params> params(
-        IncrementInteger::Params::Create(*params_value));
-    EXPECT_FALSE(params.get());
-  }
-}
-
-TEST(JsonSchemaCompilerSimpleTest, OptionalStringParamsCreate) {
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    scoped_ptr<OptionalString::Params> params(
-        OptionalString::Params::Create(*params_value));
-    EXPECT_TRUE(params.get());
-    EXPECT_FALSE(params->str.get());
-  }
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    params_value->Append(new base::StringValue("asdf"));
-    scoped_ptr<OptionalString::Params> params(
-        OptionalString::Params::Create(*params_value));
-    EXPECT_TRUE(params.get());
-    EXPECT_TRUE(params->str.get());
-    EXPECT_EQ("asdf", *params->str);
-  }
-}
-
-TEST(JsonSchemaCompilerSimpleTest, OptionalParamsTakingNull) {
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    params_value->Append(base::Value::CreateNullValue());
-    scoped_ptr<OptionalString::Params> params(
-        OptionalString::Params::Create(*params_value));
-    EXPECT_TRUE(params.get());
-    EXPECT_FALSE(params->str.get());
-  }
-}
-
-TEST(JsonSchemaCompilerSimpleTest, OptionalStringParamsWrongType) {
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    params_value->Append(new base::FundamentalValue(5));
-    scoped_ptr<OptionalString::Params> params(
-        OptionalString::Params::Create(*params_value));
-    EXPECT_FALSE(params.get());
-  }
-}
-
-TEST(JsonSchemaCompilerSimpleTest, OptionalBeforeRequired) {
-  {
-    scoped_ptr<base::ListValue> params_value(new base::ListValue());
-    params_value->Append(base::Value::CreateNullValue());
-    params_value->Append(new base::StringValue("asdf"));
-    scoped_ptr<OptionalBeforeRequired::Params> params(
-        OptionalBeforeRequired::Params::Create(*params_value));
-    EXPECT_TRUE(params.get());
-    EXPECT_FALSE(params->first.get());
-    EXPECT_EQ("asdf", params->second);
-  }
-}
-
-TEST(JsonSchemaCompilerSimpleTest, NoParamsResultCreate) {
-  scoped_ptr<base::ListValue> results = OptionalString::Results::Create();
-  base::ListValue expected;
-  EXPECT_TRUE(results->Equals(&expected));
-}
-
-TEST(JsonSchemaCompilerSimpleTest, TestTypePopulate) {
-  {
-    scoped_ptr<TestType> test_type(new TestType());
-    scoped_ptr<base::DictionaryValue> value = CreateTestTypeDictionary();
-    EXPECT_TRUE(TestType::Populate(*value, test_type.get()));
-    EXPECT_EQ("bling", test_type->string);
-    EXPECT_EQ(1.1, test_type->number);
-    EXPECT_EQ(4, test_type->integer);
-    EXPECT_EQ(true, test_type->boolean);
-    EXPECT_TRUE(value->Equals(test_type->ToValue().get()));
-  }
-  {
-    scoped_ptr<TestType> test_type(new TestType());
-    scoped_ptr<base::DictionaryValue> value = CreateTestTypeDictionary();
-    value->Remove("number", NULL);
-    EXPECT_FALSE(TestType::Populate(*value, test_type.get()));
-  }
-}
-
-TEST(JsonSchemaCompilerSimpleTest, GetTestType) {
-  {
-    scoped_ptr<base::DictionaryValue> value = CreateTestTypeDictionary();
-    scoped_ptr<TestType> test_type(new TestType());
-    EXPECT_TRUE(TestType::Populate(*value, test_type.get()));
-    scoped_ptr<base::ListValue> results =
-        GetTestType::Results::Create(*test_type);
-
-    base::DictionaryValue* result = NULL;
-    results->GetDictionary(0, &result);
-    EXPECT_TRUE(result->Equals(value.get()));
-  }
-}
-
-TEST(JsonSchemaCompilerSimpleTest, OnIntegerFiredCreate) {
-  {
-    scoped_ptr<base::ListValue> results(OnIntegerFired::Create(5));
-    base::ListValue expected;
-    expected.Append(new base::FundamentalValue(5));
-    EXPECT_TRUE(results->Equals(&expected));
-  }
-}
-
-TEST(JsonSchemaCompilerSimpleTest, OnStringFiredCreate) {
-  {
-    scoped_ptr<base::ListValue> results(OnStringFired::Create("yo dawg"));
-    base::ListValue expected;
-    expected.Append(new base::StringValue("yo dawg"));
-    EXPECT_TRUE(results->Equals(&expected));
-  }
-}
-
-TEST(JsonSchemaCompilerSimpleTest, OnTestTypeFiredCreate) {
-  {
-    TestType some_test_type;
-    scoped_ptr<base::DictionaryValue> expected = CreateTestTypeDictionary();
-    ASSERT_TRUE(expected->GetDouble("number", &some_test_type.number));
-    ASSERT_TRUE(expected->GetString("string", &some_test_type.string));
-    ASSERT_TRUE(expected->GetInteger("integer", &some_test_type.integer));
-    ASSERT_TRUE(expected->GetBoolean("boolean", &some_test_type.boolean));
-
-    scoped_ptr<base::ListValue> results(
-        OnTestTypeFired::Create(some_test_type));
-    base::DictionaryValue* result = NULL;
-    results->GetDictionary(0, &result);
-    EXPECT_TRUE(result->Equals(expected.get()));
-  }
-}
diff --git a/tools/json_schema_compiler/test/tabs.json b/tools/json_schema_compiler/test/tabs.json
deleted file mode 100644
index 7dca080..0000000
--- a/tools/json_schema_compiler/test/tabs.json
+++ /dev/null
@@ -1,770 +0,0 @@
-[
-  {
-    "namespace": "tabs",
-    "description": "The tabs API.",
-    "types": [
-      {
-        "id": "Tab",
-        "type": "object",
-        "properties": {
-          "id": {"type": "integer", "minimum": 0, "description": "The ID of the tab. Tab IDs are unique within a browser session."},
-          "index": {"type": "integer", "minimum": 0, "description": "The zero-based index of the tab within its window."},
-          "windowId": {"type": "integer", "minimum": 0, "description": "The ID of the window the tab is contained within."},
-          "selected": {"type": "boolean", "description": "Whether the tab is selected.", "nodoc": true},
-          "highlighted": {"type": "boolean", "description": "Whether the tab is highlighted."},
-          "active": {"type": "boolean", "description": "Whether the tab is active in its window."},
-          "pinned": {"type": "boolean", "description": "Whether the tab is pinned."},
-          "url": {"type": "string", "description": "The URL the tab is displaying."},
-          "title": {"type": "string", "optional": true, "description": "The title of the tab. This may not be available if the tab is loading."},
-          "favIconUrl": {"type": "string", "optional": true, "description": "The URL of the tab's favicon. This may not be available if the tab is loading."},
-          "status": {"type": "string", "optional": true, "description": "Either <em>loading</em> or <em>complete</em>."},
-          "incognito": {"type": "boolean", "description": "Whether the tab is in an incognito window."}
-        }
-      }
-    ],
-    "functions": [
-      {
-        "name": "get",
-        "type": "function",
-        "description": "Retrieves details about the specified tab.",
-        "parameters": [
-          {
-            "type": "integer",
-            "name": "tabId",
-            "minimum": 0
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {"name": "tab", "$ref": "Tab"}
-            ]
-          }
-        ]
-      },
-      {
-        "name": "getCurrent",
-        "type": "function",
-        "description": "Gets the tab that this script call is being made from. May be undefined if called from a non-tab context (for example: a background page or popup view).",
-        "parameters": [
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "tab",
-                "$ref": "Tab",
-                "optional": true
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "connect",
-        "nocompile": true,
-        "type": "function",
-        "description": "Connects to the content script(s) in the specified tab. The <a href='extension.html#event-onConnect'>chrome.runtime.onConnect</a> event is fired in each content script running in the specified tab for the current extension. For more details, see <a href='content_scripts.html#messaging'>Content Script Messaging</a>.",
-        "parameters": [
-          {
-            "type": "integer",
-            "name": "tabId",
-            "minimum": 0
-          },
-          {
-            "type": "object",
-            "name": "connectInfo",
-            "properties": {
-              "name": { "type": "string", "optional": true, "description": "Will be passed into onConnect for content scripts that are listening for the connection event." }
-            },
-            "optional": true
-          }
-        ],
-        "returns": {
-          "$ref": "Port",
-          "description": "A port that can be used to communicate with the content scripts running in the specified tab. The port's <a href='extension.html#type-Port'>onDisconnect</a> event is fired if the tab closes or does not exist. "
-        }
-      },
-      {
-        "name": "sendRequest",
-        "nocompile": true,
-        "type": "function",
-        "description": "Sends a single request to the content script(s) in the specified tab, with an optional callback to run when a response is sent back.  The <a href='extension.html#event-onRequest'>chrome.extension.onRequest</a> event is fired in each content script running in the specified tab for the current extension.",
-        "parameters": [
-          {
-            "type": "integer",
-            "name": "tabId",
-            "minimum": 0
-          },
-          {
-            "type": "any",
-            "name": "request"
-          },
-          {
-            "type": "function",
-            "name": "responseCallback",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "response",
-                "type": "any",
-                "description": "The JSON response object sent by the handler of the request. If an error occurs while connecting to the specified tab, the callback will be called with no arguments and <a href='extension.html#property-lastError'>chrome.runtime.lastError</a> will be set to the error message."
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "getSelected",
-        "nodoc": true,
-        "type": "function",
-        "description": "Deprecated. Please use query({'active': true}). Gets the tab that is selected in the specified window.",
-        "parameters": [
-          {
-            "type": "integer",
-            "name": "windowId",
-            "minimum": 0,
-            "optional": true,
-            "description": "Defaults to the <a href='windows.html#current-window'>current window</a>."
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {"name": "tab", "$ref": "Tab"}
-            ]
-          }
-        ]
-      },
-      {
-        "name": "getAllInWindow",
-        "type": "function",
-        "nodoc": true,
-        "description": "Deprecated. Please use query({'windowId': windowId}). Gets details about all tabs in the specified window.",
-        "parameters": [
-          {
-            "type": "integer",
-            "name": "windowId",
-            "minimum": 0,
-            "optional": true,
-            "description": "Defaults to the <a href='windows.html#current-window'>current window</a>."
-            },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {"name": "tabs", "type": "array", "items": { "$ref": "Tab" } }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "create",
-        "type": "function",
-        "description": "Creates a new tab. Note: This function can be used without requesting the 'tabs' permission in the manifest.",
-        "parameters": [
-          {
-            "type": "object",
-            "name": "createProperties",
-            "properties": {
-              "windowId": {
-                "type": "integer",
-                "minimum": 0,
-                "optional": true,
-                "description": "The window to create the new tab in. Defaults to the <a href='windows.html#current-window'>current window</a>."
-              },
-              "index": {
-                "type": "integer",
-                "minimum": 0,
-                "optional": true,
-                "description": "The position the tab should take in the window. The provided value will be clamped to between zero and the number of tabs in the window."
-              },
-              "url": {
-                "type": "string",
-                "optional": true,
-                "description": "The URL to navigate the tab to initially. Fully-qualified URLs must include a scheme (i.e. 'http://www.google.com', not 'www.google.com'). Relative URLs will be relative to the current page within the extension. Defaults to the New Tab Page."
-              },
-              "active": {
-                "type": "boolean",
-                "optional": true,
-                "description": "Whether the tab should become the active tab in the window. Defaults to <var>true</var>"
-              },
-              "selected": {
-                "nodoc": true,
-                "type": "boolean",
-                "optional": true,
-                "description": "Whether the tab should become the selected tab in the window. Defaults to <var>true</var>"
-              },
-              "pinned": {
-                "type": "boolean",
-                "optional": true,
-                "description": "Whether the tab should be pinned. Defaults to <var>false</var>"
-              }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "tab",
-                "$ref": "Tab",
-                "description": "Details about the created tab. Will contain the ID of the new tab."
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "query",
-        "type": "function",
-        "description": "Gets all tabs that have the specified properties, or all tabs if no properties are specified.",
-        "parameters": [
-          {
-            "type": "object",
-            "name": "queryInfo",
-            "properties": {
-              "active": {
-                "type": "boolean",
-                "optional": true,
-                "description": "Whether the tabs are active in their windows."
-              },
-              "pinned": {
-                "type": "boolean",
-                "optional": true,
-                "description": "Whether the tabs are pinned."
-              },
-              "highlighted": {
-                "type": "boolean",
-                "optional": true,
-                "description": "Whether the tabs are highlighted."
-              },
-              "status": {
-                "type": "string",
-                "optional": true,
-                "enum": ["loading", "complete"],
-                "description": "Whether the tabs have completed loading."
-              },
-              "title": {
-                "type": "string",
-                "optional": true,
-                "description": "Match page titles against a pattern."
-              },
-              "url": {
-                "type": "string",
-                "optional": true,
-                "description": "Match tabs against a URL pattern."
-              },
-              "windowId": {
-                "type": "integer",
-                "optional": true,
-                "minimum": 0,
-                "description": "The ID of the parent window."
-              },
-              "windowType": {
-                "type": "string",
-                "optional": true,
-                "enum": ["normal", "popup", "panel", "app"],
-                "description": "The type of window the tabs are in."
-              }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "result",
-                "type": "array",
-                "items": {
-                  "$ref": "Tab"
-                }
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "highlight",
-        "type": "function",
-        "description": "Highlights the given tabs.",
-        "parameters": [
-          {
-            "type": "object",
-            "name": "highlightInfo",
-            "properties": {
-               "windowId": {
-                 "type": "integer",
-                 "description": "The window that contains the tabs."
-               },
-               "tabs": {
-                 "description": "One or more tab indices to highlight.",
-                 "choices": [
-                   {"type": "array", "items": {"type": "integer", "minimum": 0}},
-                   {"type": "integer"}
-                 ]
-               }
-             }
-           },
-           {
-             "type": "function",
-             "name": "callback",
-             "parameters": [
-               {
-                 "name": "window",
-                 "$ref": "Window",
-                 "description": "Contains details about the window whose tabs were highlighted."
-               }
-             ]
-           }
-        ]
-      },
-      {
-        "name": "update",
-        "type": "function",
-        "description": "Modifies the properties of a tab. Properties that are not specified in <var>updateProperties</var> are not modified. Note: This function can be used without requesting the 'tabs' permission in the manifest.",
-        "parameters": [
-          {
-            "type": "integer",
-            "name": "tabId",
-            "minimum": 0,
-            "optional": true,
-            "description": "Defaults to the selected tab of the <a href='windows.html#current-window'>current window</a>."
-          },
-          {
-            "type": "object",
-            "name": "updateProperties",
-            "properties": {
-              "url": {
-                "optional": true,
-                "type": "string",
-                "description": "A URL to navigate the tab to."
-              },
-              "active": {
-                "type": "boolean",
-                "optional": true,
-                "description": "Whether the tab should be active."
-              },
-              "highlighted": {
-                "type": "boolean",
-                "optional": true,
-                "description": "Adds or removes the tab from the current selection."
-              },
-              "selected": {
-                "nodoc": true,
-                "type": "boolean",
-                "optional": true,
-                "description": "Whether the tab should be selected."
-              },
-              "pinned": {
-                "type": "boolean",
-                "optional": true,
-                "description": "Whether the tab should be pinned."
-              }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "tab",
-                "$ref": "Tab",
-                "optional": true,
-                "description": "Details about the updated tab, or <code>null</code> if the 'tabs' permission has not been requested."
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "move",
-        "type": "function",
-        "description": "Moves one or more tabs to a new position within its window, or to a new window. Note that tabs can only be moved to and from normal (window.type === \"normal\") windows.",
-        "parameters": [
-          {
-            "name": "tabIds",
-            "description": "The tab or list of tabs to move.",
-            "choices": [
-              {"type": "integer", "minimum": 0},
-              {"type": "array", "items": {"type": "integer", "minimum": 0}}
-            ]
-          },
-          {
-            "type": "object",
-            "name": "moveProperties",
-            "properties": {
-              "windowId": {
-                "type": "integer",
-                "minimum": 0,
-                "optional": true,
-                "description": "Defaults to the window the tab is currently in."
-              },
-              "index": {
-                "type": "integer",
-                "minimum": 0,
-                "description": "The position to move the window to. The provided value will be clamped to between zero and the number of tabs in the window."
-              }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "tabs",
-                "description": "Details about the moved tabs.",
-                "choices": [
-                  {"$ref": "Tab"},
-                  {"type": "array", "items": {"$ref": "Tab"}}
-                ]
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "reload",
-        "type": "function",
-        "description": "Reload a tab.",
-        "parameters": [
-          {"type": "integer", "name": "tabId", "optional": true, "description": "The ID of the tab to reload; defaults to the selected tab of the current window."},
-          {
-            "type": "object",
-            "name": "reloadProperties",
-            "optional": true,
-            "properties": {
-              "bypassCache": {
-                "type": "boolean",
-                "optional": true,
-                "description": "Whether using any local cache. Default is false."
-              }
-            }
-          },
-          {"type": "function", "name": "callback", "optional": true, "parameters": []}
-        ]
-      },
-      {
-        "name": "remove",
-        "type": "function",
-        "description": "Closes one or more tabs. Note: This function can be used without requesting the 'tabs' permission in the manifest.",
-        "parameters": [
-          {
-            "name": "tabIds",
-            "description": "The tab or list of tabs to close.",
-            "choices": [
-              {"type": "integer", "minimum": 0},
-              {"type": "array", "items": {"type": "integer", "minimum": 0}}
-            ]
-          },
-          {"type": "function", "name": "callback", "optional": true, "parameters": []}
-        ]
-      },
-      {
-        "name": "detectLanguage",
-        "type": "function",
-        "description": "Detects the primary language of the content in a tab.",
-        "parameters": [
-          {
-            "type": "integer",
-            "name": "tabId",
-            "minimum": 0,
-            "optional": true,
-            "description": "Defaults to the active tab of the <a href='windows.html#current-window'>current window</a>."
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "type": "string",
-                "name": "language",
-                "description": "An ISO language code such as <code>en</code> or <code>fr</code>. For a complete list of languages supported by this method, see <a href='http://src.chromium.org/viewvc/chrome/trunk/src/third_party/cld/languages/internal/languages.cc'>kLanguageInfoTable</a>. The 2nd to 4th columns will be checked and the first non-NULL value will be returned except for Simplified Chinese for which zh-CN will be returned. For an unknown language, <code>und</code> will be returned."
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "captureVisibleTab",
-        "type": "function",
-        "description": "Captures the visible area of the currently active tab in the specified window. You must have <a href='manifest.html#permissions'>&lt;all_urls&gt;</a> permission to use this method.",
-        "parameters": [
-          {
-            "type": "integer",
-            "name": "windowId",
-            "minimum": 0,
-            "optional": true,
-            "description": "The target window. Defaults to the <a href='windows.html#current-window'>current window</a>."
-          },
-          {
-            "type": "object",
-            "name": "options",
-            "optional": true,
-            "description": "Set parameters of image capture, such as the format of the resulting image.",
-            "properties": {
-              "format": {
-                "type": "string",
-                "optional": true,
-                "enum": ["jpeg", "png"],
-                "description": "The format of the resulting image.  Default is jpeg."
-              },
-              "quality": {
-                "type": "integer",
-                "name": "quality",
-                "optional": true,
-                "minimum": 0,
-                "maximum": 100,
-                "description": "When format is 'jpeg', controls the quality of the resulting image.  This value is ignored for PNG images.  As quality is decreased, the resulting image will have more visual artifacts, and the number of bytes needed to store it will decrease."
-              }
-            }
-          },
-          {
-            "type": "function", "name": "callback", "parameters": [
-              {"type": "string", "name": "dataUrl", "description": "A data URL which encodes an image of the visible area of the captured tab. May be assigned to the 'src' property of an HTML Image element for display."}
-            ]
-          }
-        ]
-      },
-      {
-        "name": "executeScript",
-        "type": "function",
-        "description": "Injects JavaScript code into a page. For details, see the <a href='content_scripts.html#pi'>programmatic injection</a> section of the content scripts doc.",
-        "parameters": [
-          {"type": "integer", "name": "tabId", "optional": true, "description": "The ID of the tab in which to run the script; defaults to the active tab of the current window."},
-          {
-            "type": "object",
-            "name": "details",
-            "description": "Details of the script to run. Either the code or the file property must be set, but both may not be set at the same time.",
-            "properties": {
-              "code": {"type": "string", "optional": true, "description": "JavaScript code to execute."},
-              "file": {"type": "string", "optional": true, "description": "JavaScript file to execute."},
-              "allFrames": {"type": "boolean", "optional": true, "description": "If allFrames is true, this function injects script into all frames of current page. By default, it's false and script is injected only into the top main frame."}
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "description": "Called after all the JavaScript has been executed.",
-            "parameters": []
-          }
-        ]
-      },
-      {
-        "name": "insertCSS",
-        "type": "function",
-        "description": "Injects CSS into a page. For details, see the <a href='content_scripts.html#pi'>programmatic injection</a> section of the content scripts doc.",
-        "parameters": [
-          {"type": "integer", "name": "tabId", "optional": true, "description": "The ID of the tab in which to insert the CSS; defaults to the active tab of the current window."},
-          {
-            "type": "object",
-            "name": "details",
-            "description": "Details of the CSS text to insert. Either the code or the file property must be set, but both may not be set at the same time.",
-            "properties": {
-              "code": {"type": "string", "optional": true, "description": "CSS code to be injected."},
-              "file": {"type": "string", "optional": true, "description": "CSS file to be injected."},
-              "allFrames": {"type": "boolean", "optional": true, "description": "If allFrames is true, this function injects CSS text into all frames of current page. By default, it's false and CSS is injected only into the top main frame."}
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "description": "Called when all the CSS has been inserted.",
-            "parameters": []
-          }
-        ]
-      }
-    ],
-    "events": [
-      {
-        "name": "onCreated",
-        "type": "function",
-        "description": "Fired when a tab is created. Note that the tab's URL may not be set at the time this event fired, but you can listen to onUpdated events to be notified when a URL is set.",
-        "parameters": [
-          {
-            "$ref": "Tab",
-            "name": "tab",
-            "description": "Details of the tab that was created."
-          }
-        ]
-      },
-      {
-        "name": "onUpdated",
-        "type": "function",
-        "description": "Fired when a tab is updated.",
-        "parameters": [
-          {"type": "integer", "name": "tabId", "minimum": 0},
-          {
-            "type": "object",
-            "name": "changeInfo",
-            "description": "Lists the changes to the state of the tab that was updated.",
-            "properties": {
-              "status": {
-                "type": "string",
-                "optional": true,
-                "description": "The status of the tab. Can be either <em>loading</em> or <em>complete</em>."
-              },
-              "url": {
-                "type": "string",
-                "optional": true,
-                "description": "The tab's URL if it has changed."
-              },
-              "pinned": {
-                "type": "boolean",
-                "optional": true,
-                "description": "The tab's new pinned state."
-              }
-            }
-          },
-          {
-            "$ref": "Tab",
-            "name": "tab",
-            "description": "Gives the state of the tab that was updated."
-          }
-        ]
-      },
-      {
-        "name": "onMoved",
-        "type": "function",
-        "description": "Fired when a tab is moved within a window. Only one move event is fired, representing the tab the user directly moved. Move events are not fired for the other tabs that must move in response. This event is not fired when a tab is moved between windows. For that, see <a href='#event-onDetached'>onDetached</a>.",
-        "parameters": [
-          {"type": "integer", "name": "tabId", "minimum": 0},
-          {
-            "type": "object",
-            "name": "moveInfo",
-            "properties": {
-              "windowId": {"type": "integer", "minimum": 0},
-              "fromIndex": {"type": "integer", "minimum": 0},
-              "toIndex": {"type": "integer", "minimum": 0}
-            }
-          }
-        ]
-      },
-      {
-        "name": "onSelectionChanged",
-        "nodoc": true,
-        "type": "function",
-        "description": "Deprecated. Please use onActiveChanged.",
-        "parameters": [
-          {
-            "type": "integer",
-            "name": "tabId",
-            "minimum": 0,
-            "description": "The ID of the tab that has become active."
-          },
-          {
-            "type": "object",
-            "name": "selectInfo",
-            "properties": {
-              "windowId": {
-                "type": "integer",
-                "minimum": 0,
-                "description": "The ID of the window the selected tab changed inside of."
-              }
-            }
-          }
-        ]
-      },
-      {
-        "name": "onActiveChanged",
-        "type": "function",
-        "description": "Fires when the selected tab in a window changes.",
-        "parameters": [
-          {
-            "type": "integer",
-            "name": "tabId",
-            "minimum": 0,
-            "description": "The ID of the tab that has become active."
-          },
-          {
-            "type": "object",
-            "name": "selectInfo",
-            "properties": {
-              "windowId": {
-                "type": "integer",
-                "minimum": 0,
-                "description": "The ID of the window the selected tab changed inside of."
-              }
-            }
-          }
-        ]
-      },
-      {
-        "name": "onHighlightChanged",
-        "type": "function",
-        "description": "Fired when the highlighted or selected tabs in a window changes.",
-        "parameters": [
-          {
-            "type": "object",
-            "name": "selectInfo",
-            "properties": {
-              "windowId": {
-                "type": "integer",
-                "minimum": 0,
-                "description": "The window whose tabs changed."
-              },
-              "tabIds": {
-                "type": "array",
-                "name": "tabIds",
-                "items": {"type": "integer", "minimum": 0},
-                "description": "All highlighted tabs in the window."
-              }
-            }
-          }
-        ]
-      },
-      {
-        "name": "onDetached",
-        "type": "function",
-        "description": "Fired when a tab is detached from a window, for example because it is being moved between windows.",
-        "parameters": [
-          {"type": "integer", "name": "tabId", "minimum": 0},
-          {
-            "type": "object",
-            "name": "detachInfo",
-            "properties": {
-              "oldWindowId": {"type": "integer", "minimum": 0},
-              "oldPosition": {"type": "integer", "minimum": 0}
-            }
-          }
-        ]
-      },
-      {
-        "name": "onAttached",
-        "type": "function",
-        "description": "Fired when a tab is attached to a window, for example because it was moved between windows.",
-        "parameters": [
-          {"type": "integer", "name": "tabId", "minimum": 0},
-          {
-            "type": "object",
-            "name": "attachInfo",
-            "properties": {
-              "newWindowId": {"type": "integer", "minimum": 0},
-              "newPosition": {"type": "integer", "minimum": 0}
-            }
-          }
-        ]
-      },
-      {
-        "name": "onRemoved",
-        "type": "function",
-        "description": "Fired when a tab is closed. Note: A listener can be registered for this event without requesting the 'tabs' permission in the manifest.",
-        "parameters": [
-          {"type": "integer", "name": "tabId", "minimum": 0},
-          {
-            "type": "object",
-            "name": "removeInfo",
-            "properties": {
-              "isWindowClosing": {"type": "boolean", "description": "True when the tab is being closed because its window is being closed." }
-            }
-          }
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/test/test_features.json b/tools/json_schema_compiler/test/test_features.json
deleted file mode 100644
index 26d67a1..0000000
--- a/tools/json_schema_compiler/test/test_features.json
+++ /dev/null
@@ -1,25 +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.
-
-{
-  "simple": {
-    "channel": "stable",
-    "extension_types": ["extension", "legacy_packaged_app"],
-    "min_manifest_version": 2
-  },
-  "complex": [
-    {
-      "channel": "dev",
-      "extension_types": ["platform_app"]
-    },
-    {
-      "channel": "stable",
-      "extension_types": ["platform_app"],
-      "whitelist": [
-        "8C3741E3AF0B93B6E8E0DDD499BB0B74839EA578",
-        "E703483CEF33DEC18B4B6DD84B5C776FB9182BDB"
-      ]
-    }
-  ]
-}
\ No newline at end of file
diff --git a/tools/json_schema_compiler/test/test_util.cc b/tools/json_schema_compiler/test/test_util.cc
deleted file mode 100644
index 79d5f7b..0000000
--- a/tools/json_schema_compiler/test/test_util.cc
+++ /dev/null
@@ -1,69 +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.
-
-#include "tools/json_schema_compiler/test/test_util.h"
-
-#include <string>
-
-#include "base/json/json_reader.h"
-#include "base/logging.h"
-
-namespace json_schema_compiler {
-namespace test_util {
-
-scoped_ptr<base::Value> ReadJson(const base::StringPiece& json) {
-  int error_code;
-  std::string error_msg;
-  scoped_ptr<base::Value> result(base::JSONReader::ReadAndReturnError(
-      json,
-      base::JSON_ALLOW_TRAILING_COMMAS,
-      &error_code,
-      &error_msg));
-  // CHECK not ASSERT since passing invalid |json| is a test error.
-  CHECK(result) << error_msg;
-  return result.Pass();
-}
-
-scoped_ptr<base::ListValue> List(base::Value* a) {
-  scoped_ptr<base::ListValue> list(new base::ListValue());
-  list->Append(a);
-  return list.Pass();
-}
-scoped_ptr<base::ListValue> List(base::Value* a, base::Value* b) {
-  scoped_ptr<base::ListValue> list = List(a);
-  list->Append(b);
-  return list.Pass();
-}
-scoped_ptr<base::ListValue> List(base::Value* a,
-                                 base::Value* b,
-                                 base::Value* c) {
-  scoped_ptr<base::ListValue> list = List(a, b);
-  list->Append(c);
-  return list.Pass();
-}
-
-scoped_ptr<base::DictionaryValue> Dictionary(
-    const std::string& ak, base::Value* av) {
-  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetWithoutPathExpansion(ak, av);
-  return dict.Pass();
-}
-scoped_ptr<base::DictionaryValue> Dictionary(
-    const std::string& ak, base::Value* av,
-    const std::string& bk, base::Value* bv) {
-  scoped_ptr<base::DictionaryValue> dict = Dictionary(ak, av);
-  dict->SetWithoutPathExpansion(bk, bv);
-  return dict.Pass();
-}
-scoped_ptr<base::DictionaryValue> Dictionary(
-    const std::string& ak, base::Value* av,
-    const std::string& bk, base::Value* bv,
-    const std::string& ck, base::Value* cv) {
-  scoped_ptr<base::DictionaryValue> dict = Dictionary(ak, av, bk, bv);
-  dict->SetWithoutPathExpansion(ck, cv);
-  return dict.Pass();
-}
-
-}  // namespace test_util
-}  // namespace json_schema_compiler
diff --git a/tools/json_schema_compiler/test/test_util.h b/tools/json_schema_compiler/test/test_util.h
deleted file mode 100644
index 7590004..0000000
--- a/tools/json_schema_compiler/test/test_util.h
+++ /dev/null
@@ -1,55 +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.
-
-#ifndef TOOLS_JSON_SCHEMA_COMPILER_TEST_TEST_UTIL_H_
-#define TOOLS_JSON_SCHEMA_COMPILER_TEST_TEST_UTIL_H_
-
-#include "base/memory/scoped_ptr.h"
-#include "base/strings/string_piece.h"
-#include "base/values.h"
-
-namespace json_schema_compiler {
-namespace test_util {
-
-scoped_ptr<base::Value> ReadJson(const base::StringPiece& json);
-
-template <typename T>
-std::vector<T> Vector(const T& a) {
-  std::vector<T> arr;
-  arr.push_back(a);
-  return arr;
-}
-template <typename T>
-std::vector<T> Vector(const T& a, const T& b) {
-  std::vector<T> arr = Vector(a);
-  arr.push_back(b);
-  return arr;
-}
-template <typename T>
-std::vector<T> Vector(const T& a, const T& b, const T& c) {
-  std::vector<T> arr = Vector(a, b);
-  arr.push_back(c);
-  return arr;
-}
-
-scoped_ptr<base::ListValue> List(base::Value* a);
-scoped_ptr<base::ListValue> List(base::Value* a, base::Value* b);
-scoped_ptr<base::ListValue> List(base::Value* a,
-                                 base::Value* b,
-                                 base::Value* c);
-
-scoped_ptr<base::DictionaryValue> Dictionary(
-    const std::string& ak, base::Value* av);
-scoped_ptr<base::DictionaryValue> Dictionary(
-    const std::string& ak, base::Value* av,
-    const std::string& bk, base::Value* bv);
-scoped_ptr<base::DictionaryValue> Dictionary(
-    const std::string& ak, base::Value* av,
-    const std::string& bk, base::Value* bv,
-    const std::string& ck, base::Value* cv);
-
-}  // namespace test_util
-}  // namespace json_schema_compiler
-
-#endif  // TOOLS_JSON_SCHEMA_COMPILER_TEST_TEST_UTIL_H_
diff --git a/tools/json_schema_compiler/test/windows.json b/tools/json_schema_compiler/test/windows.json
deleted file mode 100644
index ae90084..0000000
--- a/tools/json_schema_compiler/test/windows.json
+++ /dev/null
@@ -1,265 +0,0 @@
-[
-  {
-    "namespace": "windows",
-    "description": "The windows API.",
-    "types": [
-      {
-        "id": "Window",
-        "type": "object",
-        "properties": {
-          "id": {"type": "integer", "minimum": 0, "description": "The ID of the window. Window IDs are unique within a browser session."},
-          "focused": {"type": "boolean", "description": "Whether the window is currently the focused window."},
-          "top": {"type": "integer", "description": "The offset of the window from the top edge of the screen in pixels."},
-          "left": {"type": "integer", "description": "The offset of the window from the left edge of the screen in pixels."},
-          "width": {"type": "integer", "description": "The width of the window in pixels."},
-          "height": {"type": "integer", "description": "The height of the window in pixels."},
-          "tabs": {"type": "array", "items": { "$ref": "tabs.Tab" }, "optional": true, "description": "Array of $ref:Tab objects representing the current tabs in the window."},
-          "incognito": {"type": "boolean", "description": "Whether the window is incognito."},
-          "type": {
-            "type": "string",
-            "description": "The type of browser window this is.",
-            "enum": ["normal", "popup", "panel", "app"]
-          },
-          "state": {
-            "type": "string",
-            "description": "The state of this browser window.",
-            "enum": ["normal", "minimized", "maximized"]
-            }
-        }
-      }
-    ],
-    "properties": {
-      "WINDOW_ID_NONE": {
-        "type": "integer",
-        "value": "-1",
-        "description": "The windowId value that represents the absence of a chrome browser window."
-      }
-    },
-    "functions": [
-      {
-        "name": "get",
-        "type": "function",
-        "description": "Gets details about a window.",
-        "parameters": [
-          {"type": "integer", "name": "windowId", "minimum": 0},
-          {
-            "type": "object",
-            "name": "getInfo",
-            "optional": true,
-            "description": "",
-            "properties": {
-              "populate": {"type": "boolean", "optional": true, "description": "If true, the window object will have a <var>tabs</var> property that contains a list of the $ref:Tab objects" }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "window", "$ref": "Window"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "getCurrent",
-        "type": "function",
-        "description": "Gets the <a href='#current-window'>current window</a>.",
-        "parameters": [
-          {
-            "type": "object",
-            "name": "getInfo",
-            "optional": true,
-            "description": "",
-            "properties": {
-              "populate": {"type": "boolean", "optional": true, "description": "If true, the window object will have a <var>tabs</var> property that contains a list of the $ref:Tab objects" }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "window", "$ref": "Window"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "getLastFocused",
-        "type": "function",
-        "description": "Gets the window that was most recently focused &mdash; typically the window 'on top'.",
-        "parameters": [
-          {
-            "type": "object",
-            "name": "getInfo",
-            "optional": true,
-            "description": "",
-            "properties": {
-              "populate": {"type": "boolean", "optional": true, "description": "If true, the window object will have a <var>tabs</var> property that contains a list of the $ref:Tab objects" }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "window", "$ref": "Window"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "getAll",
-        "type": "function",
-        "description": "Gets all windows.",
-        "parameters": [
-          {
-            "type": "object",
-            "name": "getInfo",
-            "optional": true,
-            "description": "",
-            "properties": {
-              "populate": {"type": "boolean", "optional": true, "description": "If true, each window object will have a <var>tabs</var> property that contains a list of the $ref:Tab objects for that window." }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "windows", "type": "array", "items": { "$ref": "Window" }
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "create",
-        "nocompile": true,
-        "type": "function",
-        "description": "Creates (opens) a new browser with any optional sizing, position or default URL provided.",
-        "parameters": [
-          {
-            "type": "object",
-            "name": "createData",
-            "properties": {
-              "url": {
-                "type": "string",
-                "description": "A URL or list of URLs to open as tabs in the window. Fully-qualified URLs must include a scheme (i.e. 'http://www.google.com', not 'www.google.com'). Relative URLs will be relative to the current page within the extension. Defaults to the New Tab Page.",
-                "optional": true,
-                "choices": [
-                  {"type": "string"},
-                  {"type": "array", "items": {"type": "string"}}
-                ]
-              },
-              "tabId": {"type": "integer", "minimum": 0, "optional": true, "description": "The id of the tab for which you want to adopt to the new window."},
-              "left": {"type": "integer", "optional": true, "description": "The number of pixels to position the new window from the left edge of the screen. If not specified, the new window is offset naturally from the last focusd window. This value is ignored for panels."},
-              "top": {"type": "integer", "optional": true, "description": "The number of pixels to position the new window from the top edge of the screen. If not specified, the new window is offset naturally from the last focusd window. This value is ignored for panels."},
-              "width": {"type": "integer", "minimum": 0, "optional": true, "description": "The width in pixels of the new window. If not specified defaults to a natural width."},
-              "height": {"type": "integer", "minimum": 0, "optional": true, "description": "The height in pixels of the new window. If not specified defaults to a natural height."},
-              "focused": {"type": "boolean", "optional": true, "description": "If true, opens an active window. If false, opens an inactive window."},
-              "incognito": {"type": "boolean", "optional": true, "description": "Whether the new window should be an incognito window."},
-              "type": {
-                "type": "string",
-                "optional": true,
-                "description": "Specifies what type of browser window to create. The 'panel' type creates a popup unless the '--enable-panels' flag is set.",
-                "enum": ["normal", "popup", "panel"]
-              }
-            },
-            "optional": true
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "window", "$ref": "Window", "description": "Contains details about the created window.",
-                "optional": true
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "update",
-        "type": "function",
-        "description": "Updates the properties of a window. Specify only the properties that you want to change; unspecified properties will be left unchanged.",
-        "parameters": [
-          {"type": "integer", "name": "windowId", "minimum": 0},
-          {
-            "type": "object",
-            "name": "updateInfo",
-            "properties": {
-              "left": {"type": "integer", "optional": true, "description": "The offset from the left edge of the screen to move the window to in pixels. This value is ignored for panels."},
-              "top": {"type": "integer", "optional": true, "description": "The offset from the top edge of the screen to move the window to in pixels. This value is ignored for panels."},
-              "width": {"type": "integer", "minimum": 0, "optional": true, "description": "The width to resize the window to in pixels. This value is ignored for panels."},
-              "height": {"type": "integer", "minimum": 0, "optional": true, "description": "The height to resize the window to in pixels. This value is ignored for panels."},
-              "focused": {"type": "boolean", "optional": true, "description": "If true, brings the window to the front. If false, brings the next window in the z-order to the front."},
-              "drawAttention": {"type": "boolean", "optional": true, "description": "If true, causes the window to be displayed in a manner that draws the user's attention to the window, without changing the focused window. The effect lasts until the user changes focus to the window. This option has no effect if set to false or if the window already has focus."},
-              "state": {
-                "type": "string",
-                "optional": true,
-                "description": "The new state of the window. The 'minimized' and 'maximized' states cannot be combined with 'left', 'top', 'width' or 'height'.",
-                "enum": ["normal", "minimized", "maximized"]
-              }
-            }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "window", "$ref": "Window"
-              }
-            ]
-          }
-        ]
-      },
-      {
-        "name": "remove",
-        "type": "function",
-        "description": "Removes (closes) a window, and all the tabs inside it.",
-        "parameters": [
-          {"type": "integer", "name": "windowId", "minimum": 0},
-          {"type": "function", "name": "callback", "optional": true, "parameters": []}
-        ]
-      }
-    ],
-    "events": [
-      {
-        "name": "onCreated",
-        "type": "function",
-        "description": "Fired when a window is created.",
-        "parameters": [
-          {
-            "$ref": "Window",
-            "name": "window",
-            "description": "Details of the window that was created."
-          }
-        ]
-      },
-      {
-        "name": "onRemoved",
-        "type": "function",
-        "description": "Fired when a window is removed (closed).",
-        "parameters": [
-          {"type": "integer", "name": "windowId", "minimum": 0, "description": "ID of the removed window."}
-        ]
-      },
-      {
-        "name": "onFocusChanged",
-        "type": "function",
-        "description": "Fired when the currently focused window changes. Will be chrome.windows.WINDOW_ID_NONE if all chrome windows have lost focus. Note: On some Linux window managers, WINDOW_ID_NONE will always be sent immediately preceding a switch from one chrome window to another.",
-        "parameters": [
-          {"type": "integer", "name": "windowId", "minimum": -1, "description": "ID of the newly focused window."}
-        ]
-      }
-    ]
-  }
-]
diff --git a/tools/json_schema_compiler/util.cc b/tools/json_schema_compiler/util.cc
deleted file mode 100644
index 2806cfc..0000000
--- a/tools/json_schema_compiler/util.cc
+++ /dev/null
@@ -1,97 +0,0 @@
-// 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.
-
-#include "tools/json_schema_compiler/util.h"
-
-#include "base/values.h"
-
-namespace json_schema_compiler {
-namespace util {
-
-bool GetItemFromList(const base::ListValue& from, int index, int* out) {
-  return from.GetInteger(index, out);
-}
-
-bool GetItemFromList(const base::ListValue& from, int index, bool* out) {
-  return from.GetBoolean(index, out);
-}
-
-bool GetItemFromList(const base::ListValue& from, int index, double* out) {
-  return from.GetDouble(index, out);
-}
-
-bool GetItemFromList(const base::ListValue& from, int index, std::string* out) {
-  return from.GetString(index, out);
-}
-
-bool GetItemFromList(const base::ListValue& from,
-                     int index,
-                     linked_ptr<base::Value>* out) {
-  const base::Value* value = NULL;
-  if (!from.Get(index, &value))
-    return false;
-  *out = make_linked_ptr(value->DeepCopy());
-  return true;
-}
-
-bool GetItemFromList(const base::ListValue& from, int index,
-    linked_ptr<base::DictionaryValue>* out) {
-  const base::DictionaryValue* dict = NULL;
-  if (!from.GetDictionary(index, &dict))
-    return false;
-  *out = make_linked_ptr(dict->DeepCopy());
-  return true;
-}
-
-void AddItemToList(const int from, base::ListValue* out) {
-  out->Append(new base::FundamentalValue(from));
-}
-
-void AddItemToList(const bool from, base::ListValue* out) {
-  out->Append(new base::FundamentalValue(from));
-}
-
-void AddItemToList(const double from, base::ListValue* out) {
-  out->Append(new base::FundamentalValue(from));
-}
-
-void AddItemToList(const std::string& from, base::ListValue* out) {
-  out->Append(new base::StringValue(from));
-}
-
-void AddItemToList(const linked_ptr<base::Value>& from,
-                   base::ListValue* out) {
-  out->Append(from->DeepCopy());
-}
-
-void AddItemToList(const linked_ptr<base::DictionaryValue>& from,
-                   base::ListValue* out) {
-  out->Append(static_cast<base::Value*>(from->DeepCopy()));
-}
-
-std::string ValueTypeToString(base::Value::Type type) {
-  switch(type) {
-    case base::Value::TYPE_NULL:
-      return "null";
-    case base::Value::TYPE_BOOLEAN:
-      return "boolean";
-    case base::Value::TYPE_INTEGER:
-      return "integer";
-    case base::Value::TYPE_DOUBLE:
-      return "number";
-    case base::Value::TYPE_STRING:
-      return "string";
-    case base::Value::TYPE_BINARY:
-      return "binary";
-    case base::Value::TYPE_DICTIONARY:
-      return "dictionary";
-    case base::Value::TYPE_LIST:
-      return "list";
-  }
-  NOTREACHED();
-  return "";
-}
-
-}  // namespace api_util
-}  // namespace extensions
diff --git a/tools/json_schema_compiler/util.h b/tools/json_schema_compiler/util.h
deleted file mode 100644
index 228eced..0000000
--- a/tools/json_schema_compiler/util.h
+++ /dev/null
@@ -1,181 +0,0 @@
-// 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.
-
-#ifndef TOOLS_JSON_SCHEMA_COMPILER_UTIL_H__
-#define TOOLS_JSON_SCHEMA_COMPILER_UTIL_H__
-
-#include <string>
-#include <vector>
-
-#include "base/memory/linked_ptr.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/values.h"
-
-namespace json_schema_compiler {
-
-namespace util {
-
-// Creates a new item at |out| from |from|[|index|]. These are used by template
-// specializations of |Get(Optional)ArrayFromList|.
-bool GetItemFromList(const base::ListValue& from, int index, int* out);
-bool GetItemFromList(const base::ListValue& from, int index, bool* out);
-bool GetItemFromList(const base::ListValue& from, int index, double* out);
-bool GetItemFromList(const base::ListValue& from, int index, std::string* out);
-bool GetItemFromList(const base::ListValue& from,
-                     int index,
-                     linked_ptr<base::Value>* out);
-bool GetItemFromList(const base::ListValue& from,
-                     int index,
-                     linked_ptr<base::DictionaryValue>* out);
-
-// This template is used for types generated by tools/json_schema_compiler.
-template<class T>
-bool GetItemFromList(const base::ListValue& from,
-                     int index,
-                     linked_ptr<T>* out) {
-  const base::DictionaryValue* dict;
-  if (!from.GetDictionary(index, &dict))
-    return false;
-  scoped_ptr<T> obj(new T());
-  if (!T::Populate(*dict, obj.get()))
-    return false;
-  *out = linked_ptr<T>(obj.release());
-  return true;
-}
-
-// Populates |out| with |list|. Returns false if there is no list at the
-// specified key or if the list has anything other than |T|.
-template <class T>
-bool PopulateArrayFromList(
-    const base::ListValue& list, std::vector<T>* out) {
-  out->clear();
-  T value;
-  for (size_t i = 0; i < list.GetSize(); ++i) {
-    if (!GetItemFromList(list, i, &value))
-      return false;
-    out->push_back(value);
-  }
-
-  return true;
-}
-
-// Populates |out| with |from|.|name|. Returns false if there is no list at
-// the specified key or if the list has anything other than |T|.
-template <class T>
-bool PopulateArrayFromDictionary(
-    const base::DictionaryValue& from,
-    const std::string& name,
-    std::vector<T>* out) {
-  const base::ListValue* list = NULL;
-  if (!from.GetListWithoutPathExpansion(name, &list))
-    return false;
-
-  return PopulateArrayFromList(*list, out);
-}
-
-// Creates a new vector containing |list| at |out|. Returns
-// true on success or if there is nothing at the specified key. Returns false
-// if anything other than a list of |T| is at the specified key.
-template <class T>
-bool PopulateOptionalArrayFromList(
-    const base::ListValue& list,
-    scoped_ptr<std::vector<T> >* out) {
-  out->reset(new std::vector<T>());
-  T value;
-  for (size_t i = 0; i < list.GetSize(); ++i) {
-    if (!GetItemFromList(list, i, &value)) {
-      out->reset();
-      return false;
-    }
-    (*out)->push_back(value);
-  }
-
-  return true;
-}
-
-// Creates a new vector containing |from|.|name| at |out|. Returns
-// true on success or if there is nothing at the specified key. Returns false
-// if anything other than a list of |T| is at the specified key.
-template <class T>
-bool PopulateOptionalArrayFromDictionary(
-    const base::DictionaryValue& from,
-    const std::string& name,
-    scoped_ptr<std::vector<T> >* out) {
-  const base::ListValue* list = NULL;
-  {
-    const base::Value* maybe_list = NULL;
-    // Since |name| is optional, its absence is acceptable. However, anything
-    // other than a ListValue is not.
-    if (!from.GetWithoutPathExpansion(name, &maybe_list))
-      return true;
-    if (!maybe_list->IsType(base::Value::TYPE_LIST))
-      return false;
-    list = static_cast<const base::ListValue*>(maybe_list);
-  }
-
-  return PopulateOptionalArrayFromList(*list, out);
-}
-
-// Appends a Value newly created from |from| to |out|. These used by template
-// specializations of |Set(Optional)ArrayToList|.
-void AddItemToList(const int from, base::ListValue* out);
-void AddItemToList(const bool from, base::ListValue* out);
-void AddItemToList(const double from, base::ListValue* out);
-void AddItemToList(const std::string& from, base::ListValue* out);
-void AddItemToList(const linked_ptr<base::Value>& from,
-                   base::ListValue* out);
-void AddItemToList(const linked_ptr<base::DictionaryValue>& from,
-                   base::ListValue* out);
-
-// This template is used for types generated by tools/json_schema_compiler.
-template<class T>
-void AddItemToList(const linked_ptr<T>& from, base::ListValue* out) {
-  out->Append(from->ToValue().release());
-}
-
-// Set |out| to the the contents of |from|. Requires GetItemFromList to be
-// implemented for |T|.
-template <class T>
-void PopulateListFromArray(
-    const std::vector<T>& from,
-    base::ListValue* out) {
-  out->Clear();
-  for (typename std::vector<T>::const_iterator it = from.begin();
-      it != from.end(); ++it) {
-    AddItemToList(*it, out);
-  }
-}
-
-// Set |out| to the the contents of |from| if |from| is non-NULL. Requires
-// GetItemFromList to be implemented for |T|.
-template <class T>
-void PopulateListFromOptionalArray(
-    const scoped_ptr<std::vector<T> >& from,
-    base::ListValue* out) {
-  if (from.get())
-    PopulateListFromArray(*from, out);
-
-}
-
-template <class T>
-scoped_ptr<base::Value> CreateValueFromArray(const std::vector<T>& from) {
-  base::ListValue* list = new base::ListValue();
-  PopulateListFromArray(from, list);
-  return scoped_ptr<base::Value>(list);
-}
-
-template <class T>
-scoped_ptr<base::Value> CreateValueFromOptionalArray(
-    const scoped_ptr<std::vector<T> >& from) {
-  if (from.get())
-    return CreateValueFromArray(*from);
-  return scoped_ptr<base::Value>();
-}
-
-std::string ValueTypeToString(base::Value::Type type);
-
-}  // namespace util
-}  // namespace json_schema_compiler
-
-#endif // TOOLS_JSON_SCHEMA_COMPILER_UTIL_H__
diff --git a/tools/json_schema_compiler/util_cc_helper.py b/tools/json_schema_compiler/util_cc_helper.py
deleted file mode 100644
index 0e41abf..0000000
--- a/tools/json_schema_compiler/util_cc_helper.py
+++ /dev/null
@@ -1,75 +0,0 @@
-# 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.
-
-_API_UTIL_NAMESPACE = 'json_schema_compiler::util'
-
-
-class UtilCCHelper(object):
-  """A util class that generates code that uses
-  tools/json_schema_compiler/util.cc.
-  """
-  def __init__(self, type_manager):
-    self._type_manager = type_manager
-
-  def PopulateArrayFromDictionary(self, array_prop, src, name, dst):
-    """Generates code to get an array from a src.name into dst.
-
-    src: DictionaryValue*
-    dst: std::vector or scoped_ptr<std::vector>
-    """
-    prop = array_prop.item_type
-    sub = {
-        'namespace': _API_UTIL_NAMESPACE,
-        'name': name,
-        'src': src,
-        'dst': dst,
-    }
-
-    sub['type'] = self._type_manager.GetCppType(prop),
-    if array_prop.optional:
-      val = ('%(namespace)s::PopulateOptionalArrayFromDictionary'
-          '(*%(src)s, "%(name)s", &%(dst)s)')
-    else:
-      val = ('%(namespace)s::PopulateArrayFromDictionary'
-          '(*%(src)s, "%(name)s", &%(dst)s)')
-
-    return val % sub
-
-  def PopulateArrayFromList(self, src, dst, optional):
-    """Generates code to get an array from src into dst.
-
-    src: ListValue*
-    dst: std::vector or scoped_ptr<std::vector>
-    """
-    if optional:
-      val = '%(namespace)s::PopulateOptionalArrayFromList(*%(src)s, &%(dst)s)'
-    else:
-      val = '%(namespace)s::PopulateArrayFromList(*%(src)s, &%(dst)s)'
-    return val % {
-      'namespace': _API_UTIL_NAMESPACE,
-      'src': src,
-      'dst': dst
-    }
-
-  def CreateValueFromArray(self, src, optional):
-    """Generates code to create a scoped_pt<Value> from the array at src.
-
-    |src| The variable to convert, either a vector or scoped_ptr<vector>.
-    |optional| Whether |type_| was optional. Optional types are pointers so
-        must be treated differently.
-    """
-    if optional:
-      name = 'CreateValueFromOptionalArray'
-    else:
-      name = 'CreateValueFromArray'
-    return '%s::%s(%s)' % (_API_UTIL_NAMESPACE, name, src)
-
-  def GetIncludePath(self):
-    return '#include "tools/json_schema_compiler/util.h"'
-
-  def GetValueTypeString(self, value, is_ptr=False):
-    call = '.GetType()'
-    if is_ptr:
-      call = '->GetType()'
-    return 'json_schema_compiler::util::ValueTypeToString(%s%s)' % (value, call)
diff --git a/ui/accessibility/BUILD.gn b/ui/accessibility/BUILD.gn
index 043e5ef..8b0a92e 100644
--- a/ui/accessibility/BUILD.gn
+++ b/ui/accessibility/BUILD.gn
@@ -2,8 +2,6 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-import("//build/json_schema_api.gni")
-
 component("accessibility") {
   sources = [
     "ax_enums.cc",