[Extensions] Remove 'use_movable_types' from code generation

tools/json_schema_compiler/cc_generator.py

 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 from code import Code
 from model import PropertyType
 import cpp_util
 import schema_util
 import util_cc_helper
 from cpp_namespace_environment import CppNamespaceEnvironment
@@ skipping 109 matching lines @@
       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))
       )
-      if 'use_movable_types' in type_.namespace.compiler_options:
-        # Note: we use 'rhs' because some API objects have a member 'other'.
-        (c.Append('%s::%s(%s&& rhs)' %
-                      (classname_in_namespace, classname, classname))
-          .Cblock(self._GenerateMoveCtor(type_))
-          .Append('%s& %s::operator=(%s&& rhs)' %
-                      (classname_in_namespace, classname_in_namespace,
-                       classname))
-          .Cblock(self._GenerateMoveAssignOperator(type_))
-        )
+      # Note: we use 'rhs' because some API objects have a member 'other'.
+      (c.Append('%s::%s(%s&& rhs)' %
+                    (classname_in_namespace, classname, classname))
+        .Cblock(self._GenerateMoveCtor(type_))
+        .Append('%s& %s::operator=(%s&& rhs)' %
+                    (classname_in_namespace, classname_in_namespace,
+                     classname))
+        .Cblock(self._GenerateMoveAssignOperator(type_))
+      )
       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_))
       )
@@ skipping 326 matching lines @@
           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 'use_movable_types' in type_.namespace.compiler_options and
-            not self._type_helper.IsCopyable(type_.additional_properties))
         (c.Sblock('for (const auto& it : additional_properties) {')
           .Cblock(self._CreateValueFromType(
               'value->SetWithoutPathExpansion(it.first, %s);',
               type_.additional_properties.name,
               type_.additional_properties,
-              '%sit.second' % ('*' if needs_unwrap else '')))
+              'it.second'))
           .Eblock('}')
         )
 
     return (c.Append()
              .Append('return value;')
            .Eblock('}'))
 
   def _GenerateChoiceTypeToValue(self, cpp_namespace, type_):
     """Generates a function that serializes a choice-representing type
     into a base::Value.
@@ skipping 654 matching lines @@
     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)