Convert src/net to use std::string/char* for DictionaryValue keys.

net/base/transport_security_state.cc

 // Copyright (c) 2010 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 "net/base/transport_security_state.h"
 
 #include "base/base64.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 184 matching lines @@
   }
 }
 
 void TransportSecurityState::SetDelegate(
     TransportSecurityState::Delegate* delegate) {
   delegate_ = delegate;
 }
 
 // This function converts the binary hashes, which we store in
 // |enabled_hosts_|, to a base64 string which we can include in a JSON file.
-static std::wstring HashedDomainToExternalString(const std::string& hashed) {
+static std::string HashedDomainToExternalString(const std::string& hashed) {
   std::string out;
   CHECK(base::Base64Encode(hashed, &out));
-  return ASCIIToWide(out);
+  return out;
 }
 
 // This inverts |HashedDomainToExternalString|, above. It turns an external
 // string (from a JSON file) into an internal (binary) string.
 static std::string ExternalStringToHashedDomain(const std::string& external) {
   std::string out;
   if (!base::Base64Decode(external, &out) ||
       out.size() != base::SHA256_LENGTH) {
     return std::string();
   }
 
   return out;
 }
 
 bool TransportSecurityState::Serialise(std::string* output) {
   DictionaryValue toplevel;
   for (std::map<std::string, DomainState>::const_iterator
        i = enabled_hosts_.begin(); i != enabled_hosts_.end(); ++i) {
     DictionaryValue* state = new DictionaryValue;
-    state->SetBoolean(L"include_subdomains", i->second.include_subdomains);
-    state->SetReal(L"created", i->second.created.ToDoubleT());
-    state->SetReal(L"expiry", i->second.expiry.ToDoubleT());
+    state->SetBoolean("include_subdomains", i->second.include_subdomains);
+    state->SetReal("created", i->second.created.ToDoubleT());
+    state->SetReal("expiry", i->second.expiry.ToDoubleT());
 
     switch (i->second.mode) {
       case DomainState::MODE_STRICT:
-        state->SetString(L"mode", "strict");
+        state->SetString("mode", "strict");
         break;
       case DomainState::MODE_OPPORTUNISTIC:
-        state->SetString(L"mode", "opportunistic");
+        state->SetString("mode", "opportunistic");
         break;
       case DomainState::MODE_SPDY_ONLY:
-        state->SetString(L"mode", "spdy-only");
+        state->SetString("mode", "spdy-only");
         break;
       default:
         NOTREACHED() << "DomainState with unknown mode";
         delete state;
         continue;
     }
 
     toplevel.Set(HashedDomainToExternalString(i->first), state);
   }
 
@@ skipping 18 matching lines @@
        i != dict_value->end_keys(); ++i) {
     DictionaryValue* state;
     if (!dict_value->GetDictionaryWithoutPathExpansion(*i, &state))
       continue;
 
     bool include_subdomains;
     std::string mode_string;
     double created;
     double expiry;
 
-    if (!state->GetBoolean(L"include_subdomains", &include_subdomains) ||
-        !state->GetString(L"mode", &mode_string) ||
-        !state->GetReal(L"expiry", &expiry)) {
+    if (!state->GetBoolean("include_subdomains", &include_subdomains) ||
+        !state->GetString("mode", &mode_string) ||
+        !state->GetReal("expiry", &expiry)) {
       continue;
     }
 
     DomainState::Mode mode;
     if (mode_string == "strict") {
       mode = DomainState::MODE_STRICT;
     } else if (mode_string == "opportunistic") {
       mode = DomainState::MODE_OPPORTUNISTIC;
     } else if (mode_string == "spdy-only") {
       mode = DomainState::MODE_SPDY_ONLY;
     } else {
       LOG(WARNING) << "Unknown TransportSecurityState mode string found: "
                    << mode_string;
       continue;
     }
 
     base::Time expiry_time = base::Time::FromDoubleT(expiry);
     base::Time created_time;
-    if (state->GetReal(L"created", &created)) {
+    if (state->GetReal("created", &created)) {
       created_time = base::Time::FromDoubleT(created);
     } else {
       // We're migrating an old entry with no creation date. Make sure we
       // write the new date back in a reasonable time frame.
       dirtied = true;
       created_time = base::Time::Now();
     }
 
     if (expiry_time <= current_time) {
       // Make sure we dirty the state if we drop an entry.
@@ skipping 103 matching lines @@
         *include_subdomains = kPreloadedSTS[j].include_subdomains;
         return true;
       }
     }
   }
 
   return false;
 }
 
 }  // namespace