Change string data instead of binary in content settings.

components/safe_browsing/password_protection/password_protection_service.cc

 // Copyright 2017 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 "components/safe_browsing/password_protection/password_protection_service.h"
 
+#include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/history/core/browser/history_service.h"
@@ skipping 445 matching lines @@
         CONTENT_SETTINGS_TYPE_PASSWORD_PROTECTION, base::Time(),
         base::Bind(&OriginMatchPrimaryPattern, url_key));
   }
 }
 
 // static
 bool PasswordProtectionService::ParseVerdictEntry(
     base::DictionaryValue* verdict_entry,
     int* out_verdict_received_time,
     LoginReputationClientResponse* out_verdict) {
-  base::Value* binary_value = nullptr;
-  bool result = verdict_entry && out_verdict &&
-                verdict_entry->GetInteger(kCacheCreationTime,
-                                          out_verdict_received_time) &&
-                verdict_entry->Get(kVerdictProto, &binary_value);
-  if (!result)
-    return false;
-  DCHECK(result);
-  DCHECK_EQ(base::Value::Type::BINARY, binary_value->type());
-  const auto blob = binary_value->GetBlob();
-  const std::string serialized_verdict_proto(blob.begin(), blob.end());
-  return out_verdict->ParseFromString(serialized_verdict_proto);
+  std::string serialized_verdict_proto;
+  return verdict_entry && out_verdict &&
+         verdict_entry->GetInteger(kCacheCreationTime,
+                                   out_verdict_received_time) &&
+         verdict_entry->GetString(kVerdictProto, &serialized_verdict_proto) &&
+         base::Base64Decode(serialized_verdict_proto,
+                            &serialized_verdict_proto) &&
+         out_verdict->ParseFromString(serialized_verdict_proto);
 }
 
 bool PasswordProtectionService::PathVariantsMatchCacheExpression(
     const std::vector<std::string>& generated_paths,
     const std::string& cache_expression_path) {
   for (const auto& path : generated_paths) {
     if (cache_expression_path == path)
       return true;
   }
   return false;
@@ skipping 41 matching lines @@
 
 // Convert a LoginReputationClientResponse proto into a DictionaryValue.
 std::unique_ptr<base::DictionaryValue>
 PasswordProtectionService::CreateDictionaryFromVerdict(
     const LoginReputationClientResponse* verdict,
     const base::Time& receive_time) {
   std::unique_ptr<base::DictionaryValue> result =
       base::MakeUnique<base::DictionaryValue>();
   result->SetInteger(kCacheCreationTime,
                      static_cast<int>(receive_time.ToDoubleT()));
-  // Because DictionaryValue cannot take non-UTF8 string, we need to store
-  // serialized proto in its allowed binary format instead.
-  const std::string serialized_proto(verdict->SerializeAsString());
-  const std::vector<char> verdict_blob(serialized_proto.begin(),
-                                       serialized_proto.end());
-  std::unique_ptr<base::Value> binary_value =
-      base::MakeUnique<base::Value>(verdict_blob);
-  DCHECK_EQ(base::Value::Type::BINARY, binary_value->type());
-  result->Set(kVerdictProto, std::move(binary_value));
+  std::string serialized_proto(verdict->SerializeAsString());
+  // Performs a base64 encoding on the serialized proto.
+  base::Base64Encode(serialized_proto, &serialized_proto);
+  result->SetString(kVerdictProto, serialized_proto);
   return result;
 }
 
 void PasswordProtectionService::RecordPingingDisabledReason(
     const base::Feature& feature,
     RequestOutcome reason) {
   DCHECK(feature.name == kProtectedPasswordEntryPinging.name ||
          feature.name == kPasswordFieldOnFocusPinging.name);
 
   bool is_password_entry_ping =
       feature.name == kProtectedPasswordEntryPinging.name;
 
   if (is_password_entry_ping) {
     UMA_HISTOGRAM_ENUMERATION(kPasswordEntryRequestOutcomeHistogramName, reason,
                               MAX_OUTCOME);
   } else {
     UMA_HISTOGRAM_ENUMERATION(kPasswordOnFocusRequestOutcomeHistogramName,
                               reason, MAX_OUTCOME);
   }
 }
 
 }  // namespace safe_browsing