base/value_conversions.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/value_conversions.h"
   6
   7 #include <stdint.h>
   8
   9 #include <algorithm>
  10 #include <string>
  11 #include <vector>
  12
  13 #include "base/files/file_path.h"
  14 #include "base/memory/ptr_util.h"
  15 #include "base/strings/string_number_conversions.h"
  16 #include "base/time/time.h"
  17 #include "base/unguessable_token.h"
  18 #include "base/values.h"
  19
  20 namespace base {
  21 namespace {
  22 // Helper for serialize/deserialize UnguessableToken.
  23 union UnguessableTokenRepresentation {
  24   struct Field {
  25     uint64_t high;
  26     uint64_t low;
  27   } field;
  28
  29   uint8_t buffer[sizeof(Field)];
  30 };
  31 }  // namespace
  32
  33 // |Value| internally stores strings in UTF-8, so we have to convert from the
  34 // system native code to UTF-8 and back.
  35 std::unique_ptr<Value> CreateFilePathValue(const FilePath& in_value) {
  36   return std::make_unique<Value>(in_value.AsUTF8Unsafe());
  37 }
  38
  39 bool GetValueAsFilePath(const Value& value, FilePath* file_path) {
  40   std::string str;
  41   if (!value.GetAsString(&str))
  42     return false;
  43   if (file_path)
  44     *file_path = FilePath::FromUTF8Unsafe(str);
  45   return true;
  46 }
  47
  48 // |Value| does not support 64-bit integers, and doubles do not have enough
  49 // precision, so we store the 64-bit time value as a string instead.
  50 std::unique_ptr<Value> CreateTimeDeltaValue(const TimeDelta& time) {
  51   std::string string_value = base::Int64ToString(time.ToInternalValue());
  52   return std::make_unique<Value>(string_value);
  53 }
  54
  55 bool GetValueAsTimeDelta(const Value& value, TimeDelta* time) {
  56   std::string str;
  57   int64_t int_value;
  58   if (!value.GetAsString(&str) || !base::StringToInt64(str, &int_value))
  59     return false;
  60   if (time)
  61     *time = TimeDelta::FromInternalValue(int_value);
  62   return true;
  63 }
  64
  65 std::unique_ptr<Value> CreateUnguessableTokenValue(
  66     const UnguessableToken& token) {
  67   UnguessableTokenRepresentation representation;
  68   representation.field.high = token.GetHighForSerialization();
  69   representation.field.low = token.GetLowForSerialization();
  70
  71   return std::make_unique<Value>(
  72       HexEncode(representation.buffer, sizeof(representation.buffer)));
  73 }
  74
  75 bool GetValueAsUnguessableToken(const Value& value, UnguessableToken* token) {
  76   if (!value.is_string()) {
  77     return false;
  78   }
  79
  80   // TODO(dcheng|yucliu): Make a function that accepts non vector variant and
  81   // reads a fixed number of bytes.
  82   std::vector<uint8_t> high_low_bytes;
  83   if (!HexStringToBytes(value.GetString(), &high_low_bytes)) {
  84     return false;
  85   }
  86
  87   UnguessableTokenRepresentation representation;
  88   if (high_low_bytes.size() != sizeof(representation.buffer)) {
  89     return false;
  90   }
  91
  92   std::copy(high_low_bytes.begin(), high_low_bytes.end(),
  93             std::begin(representation.buffer));
  94   *token = UnguessableToken::Deserialize(representation.field.high,
  95                                          representation.field.low);
  96   return true;
  97 }
  98
  99 }  // namespace base