Use a more suitable storage for the timezone table.

base/i18n/timezone.cc

 // Copyright 2013 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 "base/i18n/timezone.h"
 
+#include <string.h>
 #include <map>

[Mark Mentovai, 2014/10/01 20:03:52]

Chrome code puts a blank line between C and C++ system headers.

[Daniel Bratell, 2014/10/02 06:23:46]

Done.

 
 #include "base/memory/singleton.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "third_party/icu/source/i18n/unicode/timezone.h"
 
 namespace base {
 
 namespace {
 
 class TimezoneMap {
  public:
   static TimezoneMap* GetInstance() {
     return Singleton<TimezoneMap>::get();
   }
 
   std::string CountryCodeForTimezone(const std::string& olson_code) {
-    std::map<std::string, std::string>::iterator iter = map_.find(olson_code);
+    std::map<const char*, const char*, CompareCStrings>::iterator iter =
+      map_.find(olson_code.c_str());
     if (iter != map_.end())
       return iter->second;
 
     return std::string();
   }
 
  private:
   TimezoneMap() {
     // These mappings are adapted from zone.tab, which is available at
     // <http://www.ietf.org/timezones/data/zone.tab> and is a part of public
     // domain.
     struct OlsonCodeData {
-      std::string country_code;
-      std::string olson_code;
-    } olson_code_data[] = {
+      const char* country_code;
+      const char* olson_code;
+    };
+    static const OlsonCodeData olson_code_data[] = {
         { "AD", "Europe/Andorra" },
         { "AE", "Asia/Dubai" },
         { "AF", "Asia/Kabul" },
         { "AG", "America/Antigua" },
         { "AI", "America/Anguilla" },
         { "AL", "Europe/Tirane" },
         { "AM", "Asia/Yerevan" },
         { "AO", "Africa/Luanda" },
         { "AQ", "Antarctica/McMurdo" },
         { "AQ", "Antarctica/Rothera" },
@@ skipping 401 matching lines @@
         { "YT", "Indian/Mayotte" },
         { "ZA", "Africa/Johannesburg" },
         { "ZM", "Africa/Lusaka" },
         { "ZW", "Africa/Harare" },
         // The mappings below are custom additions to zone.tab.
         { "GB", "Etc/GMT" },
         { "GB", "Etc/UTC" },
         { "GB", "Etc/UCT" },
     };
 
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(olson_code_data); ++i) {
+    for (size_t i = 0; i < arraysize(olson_code_data); ++i)
       map_[olson_code_data[i].olson_code] = olson_code_data[i].country_code;
-    }
 
     // These are mapping from old codenames to new codenames. They are also
     // part of public domain, and available at
     // <http://www.ietf.org/timezones/data/backward>.
     struct LinkData {
-      std::string old_code;
-      std::string new_code;
-    } link_data[] = {
+      const char* old_code;
+      const char* new_code;
+    };
+    static const LinkData link_data[] = {
         { "Africa/Asmera", "Africa/Asmara" },
         { "Africa/Timbuktu", "Africa/Bamako" },
         { "America/Argentina/ComodRivadavia", "America/Argentina/Catamarca" },
         { "America/Atka", "America/Adak" },
         { "America/Buenos_Aires", "America/Argentina/Buenos_Aires" },
         { "America/Catamarca", "America/Argentina/Catamarca" },
         { "America/Coral_Harbour", "America/Atikokan" },
         { "America/Cordoba", "America/Argentina/Cordoba" },
         { "America/Ensenada", "America/Tijuana" },
         { "America/Fort_Wayne", "America/Indiana/Indianapolis" },
@@ skipping 92 matching lines @@
         { "US/Michigan", "America/Detroit" },
         { "US/Mountain", "America/Denver" },
         { "US/Pacific", "America/Los_Angeles" },
         { "US/Samoa", "Pacific/Pago_Pago" },
         { "UTC", "Etc/UTC" },
         { "Universal", "Etc/UTC" },
         { "W-SU", "Europe/Moscow" },
         { "Zulu", "Etc/UTC" },
     };
 
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(link_data); ++i) {
+    for (size_t i = 0; i < arraysize(link_data); ++i)
       map_[link_data[i].old_code] = map_[link_data[i].new_code];
-    }
   }
 
   friend struct DefaultSingletonTraits<TimezoneMap>;
 
-  std::map<std::string, std::string> map_;
+  struct CompareCStrings {
+    bool operator()(const char* str1, const char* str2) const {
+      return strcmp(str1, str2) < 0;
+    }
+  };
+  std::map<const char*, const char*, CompareCStrings> map_;
 
   DISALLOW_COPY_AND_ASSIGN(TimezoneMap);
 };
 
 }  // namespace
 
 std::string CountryCodeForCurrentTimezone() {

[Mark Mentovai, 2014/10/01 20:03:52]

This could maybe return a const char* now too, but if all of the callers are
just going to construct an std::string anyway, there’s not much of a point.

[Daniel Bratell, 2014/10/02 06:23:46]

The (few) callers do indeed work with std::string. I wouldn't mind pure string
pointers to be used more but it's better to create std::string at one place than
at many places so this will be fine.

   scoped_ptr<icu::TimeZone> zone(icu::TimeZone::createDefault());
   icu::UnicodeString id;
   zone->getID(id);
   string16 olson_code(id.getBuffer(), id.length());
   return TimezoneMap::GetInstance()->CountryCodeForTimezone(
       UTF16ToUTF8(olson_code));
 }
 
 }  // namespace base