[Extensions] Update generated code to support movable additional properties

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 195 matching lines @@
                  placeholders to take the property name.
     - |move_str| the string to use when moving a value; should have two
                  placeholders to take the property name.
     """
     props = []
     dicts = []
     for prop in type_.properties.values():
       t = prop.type_
 
       real_t = self._type_helper.FollowRef(t)
-      if (prop.optional or
-          t.property_type == PropertyType.ANY or
-          t.property_type == PropertyType.ARRAY or
-          t.property_type == PropertyType.BINARY or
-          t.property_type == PropertyType.CHOICES or
-          t.property_type == PropertyType.OBJECT or
-          t.property_type == PropertyType.REF or
-          t.property_type == PropertyType.STRING):
+      if (real_t.property_type != PropertyType.ENUM and # enums handled below

[Devlin, 2016/03/23 21:41:01]

drive-by - was seeing "std::move(other.enum)"

[asargent_no_longer_on_chrome, 2016/03/24 17:03:56]

optional: I don't think you necessarily need the "# enums handled below"
comment, since it's pretty easy to see that just by scanning down a bit to look
at the following elif cases

[Devlin, 2016/03/24 17:35:57]

SGTM, done.

+          (prop.optional or
+           t.property_type == PropertyType.ANY or
+           t.property_type == PropertyType.ARRAY or
+           t.property_type == PropertyType.BINARY or
+           t.property_type == PropertyType.CHOICES or
+           t.property_type == PropertyType.OBJECT or
+           t.property_type == PropertyType.REF or
+           t.property_type == PropertyType.STRING)):
         props.append(move_str % (prop.unix_name, prop.unix_name))
       elif t.property_type == PropertyType.FUNCTION:
         dicts.append(prop.unix_name)
       elif (real_t.property_type == PropertyType.ENUM or
             t.property_type == PropertyType.INTEGER or
             t.property_type == PropertyType.DOUBLE or
             t.property_type == PropertyType.BOOLEAN):
         props.append(copy_str % (prop.unix_name, prop.unix_name))
       else:
         raise TypeError(t)
 
+    if (type_.property_type == PropertyType.OBJECT and
+        type_.additional_properties is not None):
+      if type_.additional_properties.property_type == PropertyType.ANY:
+        dicts.append('additional_properties')
+      else:
+        props.append(move_str % ('additional_properties',
+                                 'additional_properties'))
+
     return (props, dicts)
 
   def _GenerateMoveCtor(self, type_):
     props, dicts = self._GetMoveProps(type_, '%s(rhs.%s)',
                                       '%s(std::move(rhs.%s))')
     s = ''
     if props:
       s = s + ': %s' % (',\n'.join(props))
     s = s + '{'
     for item in dicts:
       s = s + ('\n%s.Swap(&rhs.%s);' % (item, item))
     s = s + '\n}'
 
     return Code().Append(s)
 
   def _GenerateMoveAssignOperator(self, type_):
     props, dicts = self._GetMoveProps(type_, '%s = rhs.%s;',
                                       '%s = std::move(rhs.%s);')
     s = '{\n'
     if props:
       s = s + '\n'.join(props)
     for item in dicts:
-      s = s + ('\n%s.Swap(&rhs.%s);' % (item, item))
+      s = s + ('%s.Swap(&rhs.%s);' % (item, item))
     s = s + '\nreturn *this;\n}'
 
     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))
@@ skipping 197 matching lines @@
       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 '')))
           .Eblock('}')
         )
 
@@ skipping 661 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)