Use std::unique_ptr to express ownership of base::Value in PolicyMap::Entry

components/policy/tools/generate_policy_source.py

 #!/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.
 
 '''python %prog [options] platform chromium_os_flag template
 
 platform specifies which platform source is being generated for
   and can be one of (win, mac, linux)
 chromium_os_flag should be 1 if this is a Chromium OS build
@@ skipping 648 matching lines @@
     self.properties_nodes = map(partial(self.ResolveID, 3),
         self.properties_nodes)
 
 def _WritePolicyConstantSource(policies, os, f, riskTags):
   f.write('#include "policy/policy_constants.h"\n'
           '\n'
           '#include <algorithm>\n'
           '#include <climits>\n'
           '\n'
           '#include "base/logging.h"\n'
+          '#include "base/memory/ptr_util.h"\n'
           '#include "policy/risk_tag.h"\n'
           '#include "components/policy/core/common/policy_types.h"\n'
           '#include "components/policy/core/common/schema_internal.h"\n'
           '\n'
           'namespace policy {\n'
           '\n')
 
   # Generate the Chrome schema.
   chrome_schema = {
     'type': 'object',
@@ skipping 67 matching lines @@
                               policy.enterprise_default
       else:
         raise RuntimeError('Type %s of policy %s is not supported at '
                            'enterprise defaults' % (policy.policy_type,
                                                     policy.name))
       f.write('  if (!policy_map->Get(key::k%s)) {\n'
               '    policy_map->Set(key::k%s,\n'
               '                    POLICY_LEVEL_MANDATORY,\n'
               '                    POLICY_SCOPE_USER,\n'
               '                    POLICY_SOURCE_ENTERPRISE_DEFAULT,\n'
-              '                    %s,\n'
+              '                    base::WrapUnique(%s),\n'
               '                    NULL);\n'
               '  }\n' % (policy.name, policy.name, creation_expression))
 
   f.write('}\n'
           '#endif\n\n')
 
   f.write('const PolicyDetails* GetChromePolicyDetails('
               'const std::string& policy) {\n'
           '  // First index in kPropertyNodes of the Chrome policies.\n'
           '  static const int begin_index = %s;\n'
@@ skipping 229 matching lines @@
               (policy.policy_protobuf_type, policy.name,
                policy.id + RESERVED_IDS))
   f.write('}\n\n')
 
 
 #------------------ protobuf decoder -------------------------------#
 
 CPP_HEAD = '''
 #include <limits>
 #include <memory>
+#include <utility>
 #include <string>
 
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
 #include "components/policy/core/common/cloud/cloud_external_data_manager.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/policy_types.h"
 #include "policy/policy_constants.h"
 #include "policy/proto/cloud_policy.pb.h"
 
 using google::protobuf::RepeatedPtrField;
 
 namespace policy {
 
 namespace em = enterprise_management;
 
-base::Value* DecodeIntegerValue(google::protobuf::int64 value) {
+std::unique_ptr<base::Value> DecodeIntegerValue(
+    google::protobuf::int64 value) {
   if (value < std::numeric_limits<int>::min() ||
       value > std::numeric_limits<int>::max()) {
     LOG(WARNING) << "Integer value " << value
                  << " out of numeric limits, ignoring.";
     return nullptr;
   }
 
-  return new base::FundamentalValue(static_cast<int>(value));
+  return base::WrapUnique(
+      new base::FundamentalValue(static_cast<int>(value)));
 }
 
-base::ListValue* DecodeStringList(const em::StringList& string_list) {
-  base::ListValue* list_value = new base::ListValue;
-  RepeatedPtrField<std::string>::const_iterator entry;
-  for (entry = string_list.entries().begin();
-       entry != string_list.entries().end(); ++entry) {
-    list_value->AppendString(*entry);
-  }
+std::unique_ptr<base::ListValue> DecodeStringList(
+    const em::StringList& string_list) {
+  std::unique_ptr<base::ListValue> list_value(new base::ListValue);
+  for (const auto& entry : string_list.entries())
+    list_value->AppendString(entry);
   return list_value;
 }
 
-base::Value* DecodeJson(const std::string& json) {
+std::unique_ptr<base::Value> DecodeJson(const std::string& json) {
   std::unique_ptr<base::Value> root =
       base::JSONReader::Read(json, base::JSON_ALLOW_TRAILING_COMMAS);
 
   if (!root)
     LOG(WARNING) << "Invalid JSON string, ignoring: " << json;
 
   // Accept any Value type that parsed as JSON, and leave it to the handler to
   // convert and check the concrete type.
-  return root.release();
+  return root;
 }
 
 void DecodePolicy(const em::CloudPolicySettings& policy,
                   base::WeakPtr<CloudExternalDataManager> external_data_manager,
                   PolicyMap* map) {
 '''
 
 
 CPP_FOOT = '''}
 
@@ skipping 12 matching lines @@
     return 'DecodeStringList(%s)' % arg
   elif type == 'TYPE_DICTIONARY' or type == 'TYPE_EXTERNAL':
     return 'DecodeJson(%s)' % arg
   else:
     raise NotImplementedError('Unknown type %s' % type)
 
 
 def _CreateExternalDataFetcher(type, name):
   if type == 'TYPE_EXTERNAL':
     return 'new ExternalDataFetcher(external_data_manager, key::k%s)' % name
-  return 'NULL'
+  return 'nullptr'
 
 
 def _WritePolicyCode(f, policy):
   membername = policy.name.lower()
   proto_type = '%sPolicyProto' % policy.policy_protobuf_type
   f.write('  if (policy.has_%s()) {\n' % membername)
   f.write('    const em::%s& policy_proto = policy.%s();\n' %
           (proto_type, membername))
   f.write('    if (policy_proto.has_value()) {\n')
   f.write('      PolicyLevel level = POLICY_LEVEL_MANDATORY;\n'
           '      bool do_set = true;\n'
           '      if (policy_proto.has_policy_options()) {\n'
           '        do_set = false;\n'
           '        switch(policy_proto.policy_options().mode()) {\n'
           '          case em::PolicyOptions::MANDATORY:\n'
           '            do_set = true;\n'
           '            level = POLICY_LEVEL_MANDATORY;\n'
           '            break;\n'
           '          case em::PolicyOptions::RECOMMENDED:\n'
           '            do_set = true;\n'
           '            level = POLICY_LEVEL_RECOMMENDED;\n'
           '            break;\n'
           '          case em::PolicyOptions::UNSET:\n'
           '            break;\n'
           '        }\n'
           '      }\n'
           '      if (do_set) {\n')
-  f.write('        base::Value* value = %s;\n' %
+  f.write('        std::unique_ptr<base::Value> value(%s);\n' %
           (_CreateValue(policy.policy_type, 'policy_proto.value()')))
   # TODO(bartfab): |value| == NULL indicates that the policy value could not be
   # parsed successfully. Surface such errors in the UI.
   f.write('        if (value) {\n')
-  f.write('          ExternalDataFetcher* external_data_fetcher = %s;\n' %
+  f.write('          std::unique_ptr<ExternalDataFetcher>\n')
+  f.write('              external_data_fetcher(%s);\n' %
           _CreateExternalDataFetcher(policy.policy_type, policy.name))
   f.write('          map->Set(key::k%s, \n' % policy.name)
   f.write('                   level, \n'
           '                   POLICY_SCOPE_USER, \n'
           '                   POLICY_SOURCE_CLOUD, \n'
-          '                   value, \n'
-          '                   external_data_fetcher);\n'
+          '                   std::move(value), \n'
+          '                   std::move(external_data_fetcher));\n'
           '        }\n'
           '      }\n'
           '    }\n'
           '  }\n')
 
 
 def _WriteCloudPolicyDecoder(policies, os, f, riskTags):
   f.write(CPP_HEAD)
   for policy in policies:
     if policy.is_supported and not policy.is_device_only:
@@ skipping 26 matching lines @@
   # _WriteAppRestrictions body
   f.write('<restrictions xmlns:android="'
           'http://schemas.android.com/apk/res/android">\n\n')
   for policy in policies:
     if policy.is_supported and policy.restriction_type != 'invalid':
       WriteAppRestriction(policy)
   f.write('</restrictions>')
 
 if __name__ == '__main__':
   sys.exit(main())