[storage] Tried to make one Resources.zip file.

Signed-off-by: Viktor Govako <viktor.govako@gmail.com>

data/countries.txt

@@ -2,6 +2,11 @@
  "v": 211122,
  "id": "Countries",
  "g": [
+  {
+   "id": "Resources",
+   "s": 40570432,
+   "sha1_base64": "s5QytYD+VLl4aG4B/53ZHqcfRUw="
+  },
   {
    "id": "Abkhazia",
    "old": [

defines.hpp

@@ -6,16 +6,14 @@
 #define DATA_FILE_EXTENSION_TMP ".mwm.tmp"
 #define DIFF_FILE_EXTENSION ".mwmdiff"
 #define DIFF_APPLYING_FILE_EXTENSION ".diff.applying"
-#define FONT_FILE_EXTENSION ".ttf"
 #define OSM2FEATURE_FILE_EXTENSION ".osm2ft"
 #define EXTENSION_TMP ".tmp"
 #define RAW_GEOM_FILE_EXTENSION ".rawgeom"
-#define LOC_IDX_FILE_EXTENSION ".locidx"
-#define LOC_DATA_FILE_EXTENSION ".locdata"
 #define OSM_DATA_FILE_EXTENSION ".osm"
 #define ARCHIVE_TRACKS_FILE_EXTENSION ".track"
 #define ARCHIVE_TRACKS_ZIPPED_FILE_EXTENSION ".track.zip"
 #define STATS_EXTENSION ".stats"
+#define RESOURCES_EXTENSION ".zip"
 
 #define NODES_FILE "nodes.dat"
 #define WAYS_FILE "ways.dat"
@@ -67,21 +65,17 @@
 #define TRANSIT_FILE_EXTENSION ".transit.json"
 
 #define GEOM_INDEX_TMP_EXT ".geomidx.tmp"
-#define CELL2FEATURE_SORTED_EXT ".c2f.sorted"
-#define CELL2FEATURE_TMP_EXT ".c2f.tmp"
-
-#define LOCALITY_INDEX_TMP_EXT ".locidx.tmp"
-#define CELL2LOCALITY_SORTED_EXT ".c2l.sorted"
-#define CELL2LOCALITY_TMP_EXT ".c2l.tmp"
 
 #define COUNTRIES_FILE "countries.txt"
 #define SERVER_DATAVERSION_FILE "data_version.json"
+#define COUNTRIES_ROOT "Countries"
 
 #define COUNTRIES_META_FILE "countries_meta.txt"
 #define LEAP_SPEEDS_FILE "leap_speeds.json"
 
 #define WORLD_FILE_NAME "World"
 #define WORLD_COASTS_FILE_NAME "WorldCoasts"
+#define RESOURCES_FILE_NAME "Resources"
 
 #define SETTINGS_FILE_NAME "settings.ini"
 #define MARKETING_SETTINGS_FILE_NAME "marketing_settings.ini"
@@ -120,6 +114,4 @@
 #define MIXED_TAGS_FILE "mixed_tags.txt"
 #define MIXED_NODES_FILE "mixed_nodes.txt"
 
-#define LOCALIZATION_DESCRIPTION_SUFFIX " Description"
-
 #define BUILDING_PARTS_MAPPING_FILE "building_parts_mapping.bin"

feature_list/feature_list.cpp

@@ -340,7 +340,7 @@ int main(int argc, char ** argv)
   storage::Storage storage(countriesFile, argv[1]);
   storage.Init(&DidDownload, &WillDelete);
   auto infoGetter = storage::CountryInfoReader::CreateCountryInfoGetter(pl);
-  infoGetter->SetAffiliations(&storage.GetAffiliations());
+  infoGetter->SetAffiliations(storage.GetAffiliations());
 
   GetStyleReader().SetCurrentStyle(MapStyleMerged);
   classificator::Load();

indexer/data_source.hpp

@@ -29,8 +29,6 @@ public:
   using FeatureIdCallback = std::function<void(FeatureID const &)>;
   using StopSearchCallback = std::function<bool(void)>;
 
-  ~DataSource() override = default;
-
   /// Registers a new map.
   std::pair<MwmId, RegResult> RegisterMap(platform::LocalCountryFile const & localFile);
 

indexer/features_offsets_table.cpp

@@ -72,6 +72,7 @@ namespace feature
 
     table->m_file.Open(cont.GetFileName());
     auto p = cont.GetAbsoluteOffsetAndSize(FEATURE_OFFSETS_FILE_TAG);
+    ASSERT(p.first % 4 == 0, (p.first)); // will get troubles in succinct otherwise
     table->m_handle.Assign(table->m_file.Map(p.first, p.second, FEATURE_OFFSETS_FILE_TAG));
 
     succinct::mapper::map(table->m_table, table->m_handle.GetData<char>());

iphone/CoreApi/CoreApi/Storage/MWMMapNodeAttributes.h

@@ -36,7 +36,6 @@ NS_SWIFT_NAME(MapNodeAttributes)
 @property(nonatomic, readonly) uint64_t downloadingSize;
 @property(nonatomic, readonly) uint64_t totalUpdateSizeBytes;
 @property(nonatomic, readonly) NSString *nodeName;
-@property(nonatomic, readonly) NSString *nodeDescription;
 @property(nonatomic, readonly) MWMMapNodeStatus nodeStatus;
 @property(nonatomic, readonly) BOOL hasChildren;
 @property(nonatomic, readonly) BOOL hasParent;

iphone/CoreApi/CoreApi/Storage/MWMMapNodeAttributes.mm

@@ -73,7 +73,6 @@ static MWMMapNodeStatus convertStatus(storage::NodeStatus status) {
     _downloadedSize = attributes.m_localMwmSize;
     _downloadingSize = attributes.m_downloadingMwmSize - attributes.m_localMwmSize;
     _nodeName = @(attributes.m_nodeLocalName.c_str());
-    _nodeDescription = @(attributes.m_nodeLocalDescription.c_str());
     _nodeStatus = convertStatus(attributes.m_status);
     _hasChildren = hasChildren;
     _hasParent = hasParent;

iphone/Maps/Classes/MapViewController.mm

@@ -339,18 +339,21 @@ NSString *const kPP2BookmarkEditingSegue = @"PP2BookmarkEditing";
 
   if (isLaunchedByDeeplink)
     (void)[DeepLinkHandler.shared handleDeepLink];
-  else {
-    // TODO(vng): Uncomment update dialog when we're ready to handle more traffic.
-//  auto const todo = GetFramework().ToDoAfterUpdate();
-//  switch (todo) {
-//    case Framework::DoAfterUpdate::Migrate:
-//    case Framework::DoAfterUpdate::Nothing:
-//      break;
-//    case Framework::DoAfterUpdate::AutoupdateMaps:
-//    case Framework::DoAfterUpdate::AskForUpdateMaps:
-//      [self presentViewController:[MWMAutoupdateController instanceWithPurpose:todo] animated:YES completion:nil];
-//      break;
-//  }
+  else
+  {
+    /// @todo: Uncomment update dialog when will be ready to handle big traffic bursts.
+    /*
+    auto const todo = GetFramework().ToDoAfterUpdate();
+    switch (todo) {
+      case Framework::DoAfterUpdate::Migrate:
+      case Framework::DoAfterUpdate::Nothing:
+        break;
+      case Framework::DoAfterUpdate::AutoupdateMaps:
+      case Framework::DoAfterUpdate::AskForUpdateMaps:
+        [self presentViewController:[MWMAutoupdateController instanceWithPurpose:todo] animated:YES completion:nil];
+        break;
+    }
+    */
   }
 }
 

map/framework.cpp

@@ -119,21 +119,23 @@ Framework::FixedPosition::FixedPosition()
 
 namespace
 {
-char const kMapStyleKey[] = "MapStyleKeyV1";
-char const kAllow3dKey[] = "Allow3d";
-char const kAllow3dBuildingsKey[] = "Buildings3d";
-char const kAllowAutoZoom[] = "AutoZoom";
-char const kTrafficEnabledKey[] = "TrafficEnabled";
-char const kTransitSchemeEnabledKey[] = "TransitSchemeEnabled";
-char const kIsolinesEnabledKey[] = "IsolinesEnabled";
-char const kTrafficSimplifiedColorsKey[] = "TrafficSimplifiedColors";
-char const kLargeFontsSize[] = "LargeFontsSize";
-char const kTranslitMode[] = "TransliterationMode";
-char const kPreferredGraphicsAPI[] = "PreferredGraphicsAPI";
-char const kShowDebugInfo[] = "DebugInfo";
+std::string const kMapStyleKey = "MapStyleKeyV1";
+std::string const kAllow3dKey = "Allow3d";
+std::string const kAllow3dBuildingsKey = "Buildings3d";
+std::string const kAllowAutoZoom = "AutoZoom";
+std::string const kTrafficEnabledKey = "TrafficEnabled";
+std::string const kTransitSchemeEnabledKey = "TransitSchemeEnabled";
+std::string const kIsolinesEnabledKey = "IsolinesEnabled";
+std::string const kTrafficSimplifiedColorsKey = "TrafficSimplifiedColors";
+std::string const kLargeFontsSize = "LargeFontsSize";
+std::string const kTranslitMode = "TransliterationMode";
+std::string const kPreferredGraphicsAPI = "PreferredGraphicsAPI";
+std::string const kShowDebugInfo = "DebugInfo";
+std::string const kLastUpdateKey = "LastUpdateCheck";
 
 auto constexpr kLargeFontsScaleFactor = 1.6;
 size_t constexpr kMaxTrafficCacheSizeBytes = 64 /* Mb */ * 1024 * 1024;
+double constexpr kUpdateCheckInterval = 60 * 60 * 24;
 
 // TODO!
 // To adjust GpsTrackFilter was added secret command "?gpstrackaccuracy:xxx;"
@@ -157,29 +159,19 @@ bool ParseSetGpsTrackMinAccuracyCommand(string const & query)
   GpsTrackFilter::StoreMinHorizontalAccuracy(value);
   return true;
 }
-/*
-string MakeSearchBookingUrl(booking::Api const & bookingApi, search::CityFinder & cityFinder,
-                            FeatureType & ft)
-{
-  string name;
-  auto const & info = ft.GetID().m_mwmId.GetInfo();
-  ASSERT(info, ());
-
-  int8_t lang = feature::GetNameForSearchOnBooking(info->GetRegionData(), ft.GetNames(), name);
-
-  if (lang == StringUtf8Multilang::kUnsupportedLanguageCode)
-    return {};
-
-  string city = cityFinder.GetCityName(feature::GetCenter(ft), lang);
-
-  return bookingApi.GetSearchUrl(city, name);
-}*/
 }  // namespace
 
-pair<MwmSet::MwmId, MwmSet::RegResult> Framework::RegisterMap(
-    LocalCountryFile const & localFile)
+pair<MwmSet::MwmId, MwmSet::RegResult> Framework::RegisterMap(LocalCountryFile const & file)
 {
-  return m_featuresFetcher.RegisterMap(localFile);
+  auto const res = m_featuresFetcher.RegisterMap(file);
+  if (res.second == MwmSet::RegResult::Success)
+  {
+    auto const & id = res.first;
+    ASSERT(id.IsAlive(), ());
+    LOG(LINFO, ("Loaded", file.GetCountryName(), "map, of version", id.GetInfo()->GetVersion()));
+  }
+
+  return res;
 }
 
 void Framework::OnLocationError(TLocationError /*error*/)
@@ -382,8 +374,6 @@ Framework::Framework(FrameworkParams const & params)
 
   m_routingManager.SetTransitManager(&m_transitManager);
 
-  InitCityFinder();
-
   // Init storage with needed callback.
   m_storage.Init(bind(&Framework::OnCountryFileDownloaded, this, _1, _2),
                  bind(&Framework::OnCountryFileDelete, this, _1, _2));
@@ -451,7 +441,7 @@ void Framework::ShowNode(storage::CountryId const & countryId)
   ShowRect(CalcLimitRect(countryId, GetStorage(), GetCountryInfoGetter()));
 }
 
-void Framework::OnCountryFileDownloaded(storage::CountryId const & countryId,
+void Framework::OnCountryFileDownloaded(storage::CountryId const &,
                                         storage::LocalFilePtr const localFile)
 {
   // Soft reset to signal that mwm file may be out of date in routing caches.
@@ -461,9 +451,8 @@ void Framework::OnCountryFileDownloaded(storage::CountryId const & countryId,
 
   if (localFile && localFile->OnDisk(MapFileType::Map))
   {
-    // Add downloaded map.
-    auto p = m_featuresFetcher.RegisterMap(*localFile);
-    MwmSet::MwmId const & id = p.first;
+    auto const res = RegisterMap(*localFile);
+    MwmSet::MwmId const & id = res.first;
     if (id.IsAlive())
       rect = id.GetInfo()->m_bordersRect;
   }
@@ -547,16 +536,7 @@ void Framework::RegisterAllMaps()
   vector<shared_ptr<LocalCountryFile>> maps;
   m_storage.GetLocalMaps(maps);
   for (auto const & localFile : maps)
-  {
-    auto p = RegisterMap(*localFile);
-    if (p.second != MwmSet::RegResult::Success)
-      continue;
-
-    MwmSet::MwmId const & id = p.first;
-    ASSERT(id.IsAlive(), ());
-
-    LOG(LINFO, ("Loaded", localFile->GetCountryName(), "map, of version", id.GetInfo()->GetVersion()));
-  }
+    UNUSED_VALUE(RegisterMap(*localFile));
 }
 
 void Framework::DeregisterAllMaps()
@@ -1181,6 +1161,18 @@ void Framework::EnterForeground()
     m_drapeEngine->OnEnterForeground(secondsInBackground);
   }
 
+  double lastUpdateTime;
+  if (!settings::Get(kLastUpdateKey, lastUpdateTime) || m_startForegroundTime - lastUpdateTime > kUpdateCheckInterval)
+  {
+    /// @todo Probably GetCurrentNetworkPolicy() is better than DownloadingPolicy.
+    //if (platform::GetCurrentNetworkPolicy().CanUse())
+    if (m_storageDownloadingPolicy.IsDownloadingAllowed())
+    {
+      settings::Set(kLastUpdateKey, m_startForegroundTime);
+      m_storage.RunCountriesCheckAsync();
+    }
+  }
+
   m_trafficManager.OnEnterForeground();
 }
 
@@ -1190,7 +1182,9 @@ void Framework::InitCountryInfoGetter()
 
   auto const & platform = GetPlatform();
   m_infoGetter = CountryInfoReader::CreateCountryInfoGetter(platform);
-  m_infoGetter->SetAffiliations(&m_storage.GetAffiliations());
+
+  // Storage::GetAffiliations() pointer never changed.
+  m_infoGetter->SetAffiliations(m_storage.GetAffiliations());
 }
 
 void Framework::InitSearchAPI(size_t numThreads)
@@ -1229,6 +1223,7 @@ string Framework::GetCountryName(m2::PointD const & pt) const
   return info.m_name;
 }
 
+/*
 Framework::DoAfterUpdate Framework::ToDoAfterUpdate() const
 {
   auto const connectionStatus = Platform::ConnectionStatus();
@@ -1252,6 +1247,7 @@ Framework::DoAfterUpdate Framework::ToDoAfterUpdate() const
 
   return DoAfterUpdate::AskForUpdateMaps;
 }
+*/
 
 SearchAPI & Framework::GetSearchAPI()
 {
@@ -3092,15 +3088,6 @@ void Framework::CreateNote(osm::MapObject const & mapObject,
     DeactivateMapSelection(true /* notifyUI */);
 }
 
-storage::CountriesVec Framework::GetTopmostCountries(ms::LatLon const & latlon) const
-{
-  m2::PointD const point = mercator::FromLatLon(latlon);
-  auto const countryId = m_infoGetter->GetRegionCountryId(point);
-  storage::CountriesVec topmostCountryIds;
-  GetStorage().GetTopmostNodesFor(countryId, topmostCountryIds);
-  return topmostCountryIds;
-}
-
 namespace
 {
 vector<dp::Color> colorList = {
@@ -3330,15 +3317,10 @@ void Framework::OnRouteFollow(routing::RouterType type)
 // RoutingManager::Delegate
 void Framework::RegisterCountryFilesOnRoute(shared_ptr<routing::NumMwmIds> ptr) const
 {
-  m_storage.ForEachCountryFile(
-      [&ptr](platform::CountryFile const & file) { ptr->RegisterFile(file); });
-}
-
-void Framework::InitCityFinder()
-{
-  ASSERT(!m_cityFinder, ());
-
-  m_cityFinder = make_unique<search::CityFinder>(m_featuresFetcher.GetDataSource());
+  m_storage.ForEachCountry([&ptr](storage::Country const & country)
+  {
+    ptr->RegisterFile(country.GetFile());
+  });
 }
 
 void Framework::SetPlacePageLocation(place_page::Info & info)

map/framework.hpp

@@ -96,11 +96,6 @@ struct DownloaderSearchParams;
 
 namespace routing { namespace turns{ class Settings; } }
 
-namespace platform
-{
-class NetworkPolicy;
-}
-
 namespace descriptions
 {
 class Loader;
@@ -262,15 +257,14 @@ public:
 
   std::string GetCountryName(m2::PointD const & pt) const;
 
-  enum class DoAfterUpdate
-  {
-    Nothing,
-    AutoupdateMaps,
-    AskForUpdateMaps,
-    Migrate
-  };
-
-  DoAfterUpdate ToDoAfterUpdate() const;
+//  enum class DoAfterUpdate
+//  {
+//    Nothing,
+//    AutoupdateMaps,
+//    AskForUpdateMaps,
+//    Migrate
+//  };
+//  DoAfterUpdate ToDoAfterUpdate() const;
 
   storage::Storage & GetStorage() { return m_storage; }
   storage::Storage const & GetStorage() const { return m_storage; }
@@ -733,15 +727,9 @@ public:
   void CreateNote(osm::MapObject const & mapObject, osm::Editor::NoteProblemType const type,
                   std::string const & note);
 
-public:
-  storage::CountriesVec GetTopmostCountries(ms::LatLon const & latlon) const;
-
 private:
-  std::unique_ptr<search::CityFinder> m_cityFinder;
   CachingAddressGetter m_addressGetter;
 
-  void InitCityFinder();
-
 public:
   // TipsApi::Delegate override.
   bool HaveTransit(m2::PointD const & pt) const;

platform/constants.hpp

@@ -2,5 +2,5 @@
 
 #include <cstdint>
 
-static const uint32_t READER_CHUNK_LOG_SIZE = 10;
-static const uint32_t READER_CHUNK_LOG_COUNT = 12;
+constexpr uint32_t READER_CHUNK_LOG_SIZE = 10;
+constexpr uint32_t READER_CHUNK_LOG_COUNT = 12;

platform/country_file.cpp

@@ -12,9 +12,7 @@ using namespace std;
 
 namespace
 {
-/// \returns file name (m_name) with extension dependent on the file param.
-/// The extension could be .mwm.routing or just .mwm.
-/// The method is used for old (two components) mwm support.
+/// \returns Map's file name with extension depending on the \a file type.
 string GetNameWithExt(string const & countryFile, MapFileType file)
 {
   switch (file)
@@ -32,23 +30,30 @@ namespace platform
 {
 CountryFile::CountryFile() : m_mapSize(0) {}
 
-CountryFile::CountryFile(string name) : m_name(std::move(name)), m_mapSize(0) {}
-
-string const & CountryFile::GetName() const { return m_name; }
-
-void CountryFile::SetRemoteSize(MwmSize mapSize)
+CountryFile::CountryFile(std::string name)
+: m_name(std::move(name)), m_mapSize(0)
 {
-  m_mapSize = mapSize;
 }
 
-MwmSize CountryFile::GetRemoteSize() const
+CountryFile::CountryFile(std::string name, MwmSize size, std::string sha1)
+: m_name(std::move(name)), m_mapSize(size), m_sha1(sha1)
 {
-  return m_mapSize;
 }
 
-string GetFileName(string const & countryFile, MapFileType type)
+string CountryFile::GetFileName(MapFileType type) const
 {
-  return GetNameWithExt(countryFile, type);
+  ASSERT(!m_name.empty(), ());
+
+  if (m_name == RESOURCES_FILE_NAME)
+  {
+    std::string res = m_name + RESOURCES_EXTENSION;
+    // Map and Diff should be different to avoid conflicts.
+    if (type == MapFileType::Diff)
+      res += "diff";
+    return res;
+  }
+
+  return GetNameWithExt(m_name, type);
 }
 
 string DebugPrint(CountryFile const & file)

platform/country_file.hpp

@@ -17,18 +17,17 @@ class CountryFile
 public:
   CountryFile();
   explicit CountryFile(std::string name);
+  CountryFile(std::string name, MwmSize size, std::string sha1);
+
+  /// \returns File name with extension (for download url and save on disk) for \a type.
+  /// For example Abkhazia.mwm or Resources.zip
+  std::string GetFileName(MapFileType type) const;
 
   /// \returns Empty (invalid) CountryFile.
   bool IsEmpty() const { return m_name.empty(); }
 
-  /// \returns file name without extensions.
-  std::string const & GetName() const;
-
-  /// \note Remote size is size of mwm in bytes.
-  void SetRemoteSize(MwmSize mapSize);
-  MwmSize GetRemoteSize() const;
-
-  void SetSha1(std::string const & base64Sha1) { m_sha1 = base64Sha1; }
+  std::string const & GetName() const { return m_name; }
+  MwmSize GetRemoteSize() const { return m_mapSize; }
   std::string const & GetSha1() const { return m_sha1; }
 
   inline bool operator<(const CountryFile & rhs) const { return m_name < rhs.m_name; }
@@ -45,9 +44,5 @@ private:
   std::string m_sha1;
 };
 
-/// \returns This method returns file name with extension. For example Abkhazia.mwm.
-/// \param countryFile is a file name without extension. For example Abkhazia.
-/// \param type is type of map data.
-std::string GetFileName(std::string const & countryFile, MapFileType type);
 std::string DebugPrint(CountryFile const & file);
 }  // namespace platform

platform/downloader_utils.cpp

@@ -72,8 +72,7 @@ std::string GetFilePathByUrl(std::string const & url)
 
   auto const fileType = urlComponents[0] == kDiffsPath ? MapFileType::Diff : MapFileType::Map;
 
-  return platform::GetFileDownloadPath(dataVersion, platform::CountryFile(countryComponents[0]),
-                                       fileType);
+  return platform::GetFileDownloadPath(dataVersion, platform::CountryFile(countryComponents[0]), fileType);
 }
 
 }  // namespace downloader

platform/local_country_file.cpp

@@ -10,6 +10,7 @@
 #include "base/file_name_utils.hpp"
 #include "base/logging.hpp"
 #include "base/stl_helpers.hpp"
+#include "base/string_utils.hpp"
 
 #include <algorithm>
 #include <sstream>
@@ -32,13 +33,15 @@ void LocalCountryFile::SyncWithDisk()
   uint64_t size = 0;
 
   // Now we are not working with several files at the same time and diffs have greater priority.
+  Platform & platform = GetPlatform();
   for (MapFileType type : {MapFileType::Diff, MapFileType::Map})
   {
-    ASSERT_LESS(base::Underlying(type), m_files.size(), ());
+    auto const ut = base::Underlying(type);
+    ASSERT_LESS(ut, m_files.size(), ());
 
-    if (GetPlatform().GetFileSizeByFullPath(GetPath(type), size))
+    if (platform.GetFileSizeByFullPath(GetPath(type), size))
     {
-      m_files[base::Underlying(type)] = size;
+      m_files[ut] = size;
       break;
     }
   }
@@ -48,16 +51,18 @@ void LocalCountryFile::DeleteFromDisk(MapFileType type) const
 {
   ASSERT_LESS(base::Underlying(type), m_files.size(), ());
 
-  if (!OnDisk(type))
-    return;
-
-  if (!base::DeleteFileX(GetPath(type)))
+  if (OnDisk(type) && !base::DeleteFileX(GetPath(type)))
     LOG(LERROR, (type, "from", *this, "wasn't deleted from disk."));
 }
 
 string LocalCountryFile::GetPath(MapFileType type) const
 {
-  return base::JoinPath(m_directory, GetFileName(m_countryFile.GetName(), type));
+  return base::JoinPath(m_directory, GetFileName(type));
+}
+
+std::string LocalCountryFile::GetFileName(MapFileType type) const
+{
+  return m_countryFile.GetFileName(type);
 }
 
 uint64_t LocalCountryFile::GetSize(MapFileType type) const
@@ -70,14 +75,23 @@ uint64_t LocalCountryFile::GetSize(MapFileType type) const
 bool LocalCountryFile::HasFiles() const
 {
   return std::any_of(m_files.cbegin(), m_files.cend(),
-                     [](auto value) { return value.has_value(); });
+                     [](auto const & value) { return value.has_value(); });
 }
 
 bool LocalCountryFile::OnDisk(MapFileType type) const
 {
-  ASSERT_LESS(base::Underlying(type), m_files.size(), ());
+  auto const ut = base::Underlying(type);
+  ASSERT_LESS(ut, m_files.size(), ());
+  return m_files[ut].has_value();
+}
 
-  return m_files[base::Underlying(type)].has_value();
+LocalCountryFile::DirectoryType LocalCountryFile::GetDirectoryType() const
+{
+  if (m_directory.empty())
+    return BUNDLE;
+  if (strings::EndsWith(m_directory, RESOURCES_EXTENSION))
+    return RESOURCE;
+  return DISK_PATH;
 }
 
 bool LocalCountryFile::operator<(LocalCountryFile const & rhs) const
@@ -127,22 +141,21 @@ LocalCountryFile LocalCountryFile::MakeTemporary(string const & fullPath)
 
 string DebugPrint(LocalCountryFile const & file)
 {
-  ostringstream filesStream;
-  filesStream << "[";
+  ostringstream os;
+  os << "LocalCountryFile [" << file.m_directory << ", "
+     << DebugPrint(file.m_countryFile) << ", " << file.m_version << ", [";
+
   bool fileAdded = false;
   for (auto const & mapFile : file.m_files)
   {
     if (mapFile)
     {
-      filesStream << (fileAdded ? ", " : "") << *mapFile;
+      os << (fileAdded ? ", " : "") << *mapFile;
       fileAdded = true;
     }
   }
-  filesStream << "]";
 
-  ostringstream os;
-  os << "LocalCountryFile [" << file.m_directory << ", " << DebugPrint(file.m_countryFile) << ", "
-     << file.m_version << ", " << filesStream.str() << "]";
+  os << "]]";
   return os.str();
 }
 }  // namespace platform

platform/local_country_file.hpp

@@ -22,15 +22,11 @@ namespace platform
 // SyncWithDisk()/DeleteFromDisk()/GetPath()/GetSize() will return
 // incorrect results.
 //
-// TODO (@gorshenin): fix this hack somehow
-// (https://trello.com/c/qcveFw3M/27-world-worldcoasts-mwm-localcountryfile)
-//
 // In any case, when you're going to read a file LocalCountryFile points to,
-// use GetCountryReader().
+// use platform::GetCountryReader().
 class LocalCountryFile
 {
 public:
-  // Creates empty instance.
   LocalCountryFile();
 
   // Creates an instance holding a path to countryFile's in a
@@ -49,27 +45,30 @@ public:
   // it was found by a previous SyncWithDisk() call.
   void DeleteFromDisk(MapFileType type) const;
 
-  // Returns path to a file. Return value may be empty until
-  // SyncWithDisk() is called.
+  // Returns path to a file.
+  // Return value may be empty until SyncWithDisk() is called.
   std::string GetPath(MapFileType type) const;
+  std::string GetFileName(MapFileType type) const;
 
-  // Returns size of a file. Return value may be zero until
-  // SyncWithDisk() is called.
+  // Returns size of a file.
+  // Return value may be zero until SyncWithDisk() is called.
   uint64_t GetSize(MapFileType type) const;
 
   // Returns true when some files are found during SyncWithDisk.
   // Return value is false until SyncWithDisk() is called.
   bool HasFiles() const;
 
-  // Checks whether files specified in filesMask are on disk. Return
-  // value will be false until SyncWithDisk() is called.
+  // Checks whether files specified in filesMask are on disk.
+  // Return value will be false until SyncWithDisk() is called.
   bool OnDisk(MapFileType type) const;
 
+  enum DirectoryType { BUNDLE, RESOURCE, DISK_PATH };
+  DirectoryType GetDirectoryType() const;
+
   std::string const & GetDirectory() const { return m_directory; }
   std::string const & GetCountryName() const { return m_countryFile.GetName(); }
   int64_t GetVersion() const { return m_version; }
   CountryFile const & GetCountryFile() const { return m_countryFile; }
-  CountryFile & GetCountryFile() { return m_countryFile; }
 
   bool operator<(LocalCountryFile const & rhs) const;
   bool operator==(LocalCountryFile const & rhs) const;
@@ -78,21 +77,18 @@ public:
   bool ValidateIntegrity() const;
 
   // Creates LocalCountryFile for test purposes, for a country region
-  // with countryFileName (without any extensions). Automatically
-  // performs sync with disk.
+  // with countryFileName (without any extensions). Automatically performs sync with disk.
   static LocalCountryFile MakeForTesting(std::string const & countryFileName, int64_t version = 0);
 
-  /// @todo The easiest solution for now. Need to be removed in future.
-  /// @param fullPath Full path to the mwm file.
+  // Used in generator only to simplify getting instance from path.
   static LocalCountryFile MakeTemporary(std::string const & fullPath);
 
 private:
   friend std::string DebugPrint(LocalCountryFile const &);
-  friend void FindAllLocalMapsAndCleanup(int64_t latestVersion,
-                                         std::string const & dataDir, std::vector<LocalCountryFile> & localFiles);
+  friend void FindAllLocalMapsAndCleanup(int64_t latestVersion, std::string const & dataDir,
+                                         std::vector<LocalCountryFile> & localFiles);
 
-  /// @note! If directory is empty, the file is stored in resources.
-  /// In this case, the only valid params are m_countryFile and m_version.
+  /// @see GetDirectoryType.
   std::string m_directory;
   CountryFile m_countryFile;
   int64_t m_version;

platform/local_country_file_utils.cpp

@@ -1,5 +1,6 @@
 #include "platform/local_country_file_utils.hpp"
 
+#include "platform/constants.hpp"
 #include "platform/country_file.hpp"
 #include "platform/mwm_version.hpp"
 #include "platform/platform.hpp"
@@ -7,6 +8,7 @@
 
 #include "coding/internal/file_data.hpp"
 #include "coding/reader.hpp"
+#include "coding/zip_reader.hpp"
 
 #include "base/assert.hpp"
 #include "base/file_name_utils.hpp"
@@ -33,9 +35,7 @@ char const kBitsExt[] = ".bftsegbits";
 char const kNodesExt[] = ".bftsegnodes";
 char const kOffsetsExt[] = ".offsets";
 
-size_t const kMaxTimestampLength = 18;
-
-string GetSpecialFilesSearchScope()
+string GetAdditionalWorldScope()
 {
   return "r";
 }
@@ -57,8 +57,8 @@ bool IsDiffFile(string const & name)
 bool DirectoryHasIndexesOnly(string const & directory)
 {
   Platform::TFilesWithType fwts;
-  Platform::GetFilesByType(directory, Platform::FILE_TYPE_REGULAR | Platform::FILE_TYPE_DIRECTORY,
-                           fwts);
+  Platform::GetFilesByType(directory, Platform::FILE_TYPE_REGULAR | Platform::FILE_TYPE_DIRECTORY, fwts);
+
   for (auto const & fwt : fwts)
   {
     auto const & name = fwt.first;
@@ -67,11 +67,11 @@ bool DirectoryHasIndexesOnly(string const & directory)
     {
       if (!IsSpecialName(name))
         return false;
-      continue;
     }
-    if (!CountryIndexes::IsIndexFile(name))
+    else if (!CountryIndexes::IsIndexFile(name))
       return false;
   }
+
   return true;
 }
 
@@ -110,10 +110,10 @@ void FindAllDiffsInDirectory(string const & dir, vector<LocalCountryFile> & diff
   }
 }
 
-string GetFilePath(int64_t version, string const & dataDir, CountryFile const & countryFile,
-                   MapFileType type)
+string GetFilePath(int64_t version, string const & dataDir,
+                   CountryFile const & countryFile, MapFileType type)
 {
-  string const filename = GetFileName(countryFile.GetName(), type);
+  string const filename = countryFile.GetFileName(type);
   string const dir = GetDataDirFullPath(dataDir);
   if (version == 0)
     return base::JoinPath(dir, filename);
@@ -153,8 +153,9 @@ void FindAllLocalMapsInDirectoryAndCleanup(string const & directory, int64_t ver
   Platform & platform = GetPlatform();
 
   Platform::TFilesWithType fwts;
-  platform.GetFilesByType(directory, Platform::FILE_TYPE_REGULAR | Platform::FILE_TYPE_DIRECTORY,
-                          fwts);
+  platform.GetFilesByType(directory, Platform::FILE_TYPE_REGULAR | Platform::FILE_TYPE_DIRECTORY, fwts);
+
+  char const * resourcesFile = RESOURCES_FILE_NAME RESOURCES_EXTENSION;
 
   unordered_set<string> names;
   for (auto const & fwt : fwts)
@@ -171,15 +172,22 @@ void FindAllLocalMapsInDirectoryAndCleanup(string const & directory, int64_t ver
       continue;
     }
 
-    if (!strings::EndsWith(name, DATA_FILE_EXTENSION))
-      continue;
+    if (strings::EndsWith(name, DATA_FILE_EXTENSION))
+    {
+      // Remove DATA_FILE_EXTENSION and use base name as a country file name.
+      base::GetNameWithoutExt(name);
+      names.insert(name);
+      localFiles.emplace_back(directory, CountryFile(std::move(name)), version);
+    }
+    else if (name == resourcesFile)
+    {
+      localFiles.emplace_back(directory, CountryFile(RESOURCES_FILE_NAME), version);
 
-    // Remove DATA_FILE_EXTENSION and use base name as a country file name.
-    base::GetNameWithoutExt(name);
-    names.insert(name);
-    LocalCountryFile localFile(directory, CountryFile(name), version);
-
-    localFiles.push_back(localFile);
+      /// @todo Should we check actual MWMs presence in resource container?
+      auto const fullPath = base::JoinPath(directory, name);
+      localFiles.emplace_back(fullPath, CountryFile(WORLD_FILE_NAME), version);
+      localFiles.emplace_back(fullPath, CountryFile(WORLD_COASTS_FILE_NAME), version);
+    }
   }
 
   for (auto const & fwt : fwts)
@@ -187,14 +195,13 @@ void FindAllLocalMapsInDirectoryAndCleanup(string const & directory, int64_t ver
     if (fwt.second != Platform::FILE_TYPE_DIRECTORY)
       continue;
 
-    string name = fwt.first;
+    string const & name = fwt.first;
     if (IsSpecialName(name))
       continue;
 
     if (names.count(name) == 0 && DirectoryHasIndexesOnly(base::JoinPath(directory, name)))
     {
-      // Directory which looks like a directory with indexes for absent country. It's OK to remove
-      // it.
+      // Directory which looks like a directory with indexes for absent country. It's OK to remove it.
       LocalCountryFile absentCountry(directory, CountryFile(name), version);
       CountryIndexes::DeleteFromDisk(absentCountry);
     }
@@ -222,6 +229,8 @@ void FindAllLocalMapsAndCleanup(int64_t latestVersion, string const & dataDir,
                                 vector<LocalCountryFile> & localFiles)
 {
   string const dir = GetDataDirFullPath(dataDir);
+
+  /// @todo Should we search for files in root data folder, except minsk-pass tests?
   FindAllLocalMapsInDirectoryAndCleanup(dir, 0 /* version */, latestVersion, localFiles);
 
   Platform::TFilesWithType fwts;
@@ -240,8 +249,8 @@ void FindAllLocalMapsAndCleanup(int64_t latestVersion, string const & dataDir,
       LOG(LWARNING, ("Can't remove directory:", fullPath, err));
   }
 
-  // World and WorldCoasts can be stored in app bundle or in resources
-  // directory, thus it's better to get them via Platform.
+  // Check for World and WorldCoasts in app bundle or in resources.
+  Platform & platform = GetPlatform();
   string const world(WORLD_FILE_NAME);
   string const worldCoasts(WORLD_COASTS_FILE_NAME);
   for (string const & file : {world, worldCoasts})
@@ -255,26 +264,26 @@ void FindAllLocalMapsAndCleanup(int64_t latestVersion, string const & dataDir,
 
     try
     {
-      Platform & platform = GetPlatform();
-      ModelReaderPtr reader(
-          platform.GetReader(file + DATA_FILE_EXTENSION, GetSpecialFilesSearchScope()));
+      ModelReaderPtr reader(platform.GetReader(file + DATA_FILE_EXTENSION, GetAdditionalWorldScope()));
 
-      // Assume that empty path means the resource file.
-      LocalCountryFile worldFile{string(), CountryFile(file), version::ReadVersionDate(reader)};
-      worldFile.m_files[base::Underlying(MapFileType::Map)] = 1;
+      // Empty path means the resource file.
+      LocalCountryFile worldFile(string(), CountryFile(file), version::ReadVersionDate(reader));
+      worldFile.m_files[base::Underlying(MapFileType::Map)] = reader.Size();
+
+      // Replace if newer only.
       if (i != localFiles.end())
       {
-        // Always use resource World files instead of local on disk.
-        *i = worldFile;
+        if (worldFile.GetVersion() > i->GetVersion())
+          *i = std::move(worldFile);
       }
       else
-        localFiles.push_back(worldFile);
+        localFiles.push_back(std::move(worldFile));
     }
     catch (RootException const & ex)
     {
       if (i == localFiles.end())
       {
-        // This warning is possible on android devices without pre-downloaded Worlds/fonts files.
+        // This warning is possible on android devices without bundled Worlds.
         LOG(LWARNING, ("Can't find any:", file, "Reason:", ex.Msg()));
       }
     }
@@ -289,7 +298,8 @@ void CleanupMapsDirectory(int64_t latestVersion)
 
 bool ParseVersion(string const & s, int64_t & version)
 {
-  if (s.empty() || s.size() > kMaxTimestampLength)
+  // Folder version format is 211122. Unit tests use simple "1", "2" versions.
+  if (s.empty() || s.size() > 6)
     return false;
 
   int64_t v = 0;
@@ -326,26 +336,25 @@ string GetFileDownloadPath(int64_t version, CountryFile const & countryFile, Map
   return GetFileDownloadPath(version, string(), countryFile, type);
 }
 
-string GetFileDownloadPath(int64_t version, string const & dataDir, CountryFile const & countryFile,
-                           MapFileType type)
+string GetFileDownloadPath(int64_t version, string const & dataDir,
+                           CountryFile const & countryFile, MapFileType type)
 {
-  string const readyFile = GetFileName(countryFile.GetName(), type) + READY_FILE_EXTENSION;
-  string const dir = GetDataDirFullPath(dataDir);
-  if (version == 0)
-    return base::JoinPath(dir, readyFile);
-  return base::JoinPath(dir, strings::to_string(version), readyFile);
+  return GetFilePath(version, dataDir, countryFile, type) + READY_FILE_EXTENSION;
 }
 
-unique_ptr<ModelReader> GetCountryReader(platform::LocalCountryFile const & file, MapFileType type)
+unique_ptr<ModelReader> GetCountryReader(LocalCountryFile const & file, MapFileType type)
 {
   Platform & platform = GetPlatform();
-  // See LocalCountryFile comment for explanation.
-  if (file.GetDirectory().empty())
+  switch (file.GetDirectoryType())
   {
-    return platform.GetReader(file.GetCountryName() + DATA_FILE_EXTENSION,
-                              GetSpecialFilesSearchScope());
+  case LocalCountryFile::BUNDLE:
+    return platform.GetReader(file.GetFileName(type), GetAdditionalWorldScope());
+  case LocalCountryFile::RESOURCE:
+    return make_unique<ZipFileReader>(file.GetDirectory(), file.GetFileName(type),
+                                      READER_CHUNK_LOG_SIZE, READER_CHUNK_LOG_COUNT);
+  case LocalCountryFile::DISK_PATH:
+    return platform.GetReader(file.GetPath(type), "f");
   }
-  return platform.GetReader(file.GetPath(type), "f");
 }
 
 // static
@@ -415,11 +424,9 @@ string CountryIndexes::IndexesDir(LocalCountryFile const & localFile)
   string dir = localFile.GetDirectory();
   CountryFile const & file = localFile.GetCountryFile();
 
-  /// @todo It's a temporary code until we will put fIndex->fOffset into mwm container.
-  /// IndexesDir should not throw any exceptions.
-  if (dir.empty())
+  if (localFile.GetDirectoryType() == LocalCountryFile::BUNDLE)
   {
-    // Local file is stored in resources. Need to prepare index folder in the writable directory.
+    // Local file is stored in bundle. Need to prepare index folder in the writable directory.
     int64_t const version = localFile.GetVersion();
     ASSERT_GREATER(version, 0, ());
 

platform/local_country_file_utils.hpp

@@ -77,7 +77,8 @@ std::string GetFileDownloadPath(int64_t version, std::string const & dataDir,
 
 std::unique_ptr<ModelReader> GetCountryReader(LocalCountryFile const & file, MapFileType type);
 
-// An API for managing country indexes.
+/// An API for managing country indexes.
+/// Not used now (except tests), but will be usefull for the Terrain index in future.
 class CountryIndexes
 {
 public:
@@ -88,8 +89,7 @@ public:
     Offsets
   };
 
-  /// Prepares (if necessary) directory for country indexes. Local file
-  /// should point to existing local country files.
+  /// Prepares (if necessary) directory for country indexes.
   /// @throw FileSystemException if any file system error occured.
   static void PreparePlaceOnDisk(LocalCountryFile const & localFile);
 

platform/network_policy.hpp

@@ -21,7 +21,7 @@ public:
   bool CanUse() const { return m_canUse; }
 
 private:
-  NetworkPolicy(bool const canUseNetwork) : m_canUse(canUseNetwork) {}
+  explicit NetworkPolicy(bool canUse) : m_canUse(canUse) {}
 
   bool m_canUse = false;
 };

platform/platform.cpp

@@ -149,6 +149,18 @@ string Platform::ReadPathForFile(string const & file, string searchScope) const
       "\nw: ", m_writableDir, "\nr: ", m_resourcesDir, "\ns: ", m_settingsDir));
 }
 
+std::unique_ptr<ModelReader> Platform::GetReaderSafe(std::string const & file, std::string const & searchScope) const
+{
+  try
+  {
+    return GetReader(file, searchScope);
+  }
+  catch (RootException const &)
+  {
+  }
+  return nullptr;
+}
+
 string Platform::MetaServerUrl() const
 {
   return METASERVER_URL;

platform/platform.hpp

@@ -199,6 +199,9 @@ public:
   /// [w]ritable, [r]esources, [s]ettings, by [f]ull path, [e]xternal resources,
   std::unique_ptr<ModelReader> GetReader(std::string const & file,
                                          std::string searchScope = std::string()) const;
+  /// @return nullptr instead of throw if file not exist.
+  std::unique_ptr<ModelReader> GetReaderSafe(std::string const & file,
+                                             std::string const & searchScope = std::string()) const;
 
   /// @name File operations
   //@{

platform/platform_tests/country_file_tests.cpp

@@ -13,17 +13,23 @@ namespace platform
 {
 UNIT_TEST(CountryFile_Smoke)
 {
-  CountryFile countryFile("TestCountryOneComponent");
-  TEST_EQUAL("TestCountryOneComponent", countryFile.GetName(), ());
-  string const mapFileName =
-      GetFileName(countryFile.GetName(), MapFileType::Map);
+  {
+    CountryFile cf("One");
+    TEST_EQUAL("One", cf.GetName(), ());
+    string const mapFileName = cf.GetFileName(MapFileType::Map);
 
-  TEST_EQUAL("TestCountryOneComponent" DATA_FILE_EXTENSION, mapFileName, ());
+    TEST_EQUAL("One" DATA_FILE_EXTENSION, mapFileName, ());
+    TEST_EQUAL(0, cf.GetRemoteSize(), ());
+  }
 
-  TEST_EQUAL(0, countryFile.GetRemoteSize(), ());
+  {
+    CountryFile cf("Three", 666, "xxxSHAxxx");
+    TEST_EQUAL("Three", cf.GetName(), ());
+    string const mapFileName = cf.GetFileName(MapFileType::Map);
 
-  countryFile.SetRemoteSize(3 /* mapSize */);
-
-  TEST_EQUAL(3, countryFile.GetRemoteSize(), ());
+    TEST_EQUAL("Three" DATA_FILE_EXTENSION, mapFileName, ());
+    TEST_EQUAL(666, cf.GetRemoteSize(), ());
+    TEST_EQUAL("xxxSHAxxx", cf.GetSha1(), ());
+  }
 }
 }  // namespace platform

platform/platform_tests/downloader_utils_tests.cpp

@@ -4,17 +4,18 @@
 #include "platform/local_country_file_utils.hpp"
 #include "platform/mwm_version.hpp"
 
+using namespace platform;
+
 UNIT_TEST(UrlConversionTest)
 {
   {
-    std::string const mwmName = "Luna";
-    std::string const fileName = platform::GetFileName(mwmName, MapFileType::Map);
+    CountryFile mwmCF("Luna");
+    std::string const fileName = mwmCF.GetFileName(MapFileType::Map);
     int64_t const dataVersion = version::FOR_TESTING_MWM1;
     int64_t const diffVersion = 0;
     MapFileType const fileType = MapFileType::Map;
 
-    auto const path =
-        platform::GetFileDownloadPath(dataVersion, platform::CountryFile(mwmName), fileType);
+    auto const path = GetFileDownloadPath(dataVersion, mwmCF, fileType);
 
     auto const url = downloader::GetFileDownloadUrl(fileName, dataVersion, diffVersion);
     auto const resultPath = downloader::GetFilePathByUrl(url);
@@ -22,14 +23,13 @@ UNIT_TEST(UrlConversionTest)
     TEST_EQUAL(path, resultPath, ());
   }
   {
-    std::string const mwmName = "Luna";
-    std::string const fileName = platform::GetFileName(mwmName, MapFileType::Diff);
+    CountryFile mwmCF("Luna");
+    std::string const fileName = mwmCF.GetFileName(MapFileType::Diff);
     int64_t const dataVersion = version::FOR_TESTING_MWM2;
     int64_t const diffVersion = version::FOR_TESTING_MWM1;
     MapFileType const fileType = MapFileType::Diff;
 
-    auto const path =
-        platform::GetFileDownloadPath(dataVersion, platform::CountryFile(mwmName), fileType);
+    auto const path = GetFileDownloadPath(dataVersion, mwmCF, fileType);
 
     auto const url = downloader::GetFileDownloadUrl(fileName, dataVersion, diffVersion);
     auto const resultPath = downloader::GetFilePathByUrl(url);
@@ -40,9 +40,9 @@ UNIT_TEST(UrlConversionTest)
 
 UNIT_TEST(IsUrlSupportedTest)
 {
-  std::string const mwmName = "Luna";
+  CountryFile mwmCF("Luna");
 
-  std::string fileName = platform::GetFileName(mwmName, MapFileType::Map);
+  std::string fileName = mwmCF.GetFileName(MapFileType::Map);
   int64_t dataVersion = version::FOR_TESTING_MWM1;
   int64_t diffVersion = 0;
 
@@ -59,7 +59,7 @@ UNIT_TEST(IsUrlSupportedTest)
   TEST(!downloader::IsUrlSupported("Luna.mwm"), ());
   TEST(!downloader::IsUrlSupported("Luna"), ());
 
-  fileName = platform::GetFileName(mwmName, MapFileType::Diff);
+  fileName = mwmCF.GetFileName(MapFileType::Diff);
   diffVersion = version::FOR_TESTING_MWM1;
   url = downloader::GetFileDownloadUrl(fileName, dataVersion, diffVersion);
   TEST(downloader::IsUrlSupported(url), ());

platform/platform_tests/local_country_file_tests.cpp

@@ -51,10 +51,7 @@ UNIT_TEST(LocalCountryFile_ParseVersion)
   TEST(ParseVersion("150309", version), ());
   TEST_EQUAL(version, 150309, ());
 
-  TEST(ParseVersion("999999999999999999", version), ());
-  TEST_EQUAL(version, 999999999999999999, ());
-
-  TEST(!ParseVersion("1000000000000000000", version), ());
+  TEST(!ParseVersion("2111225", version), ());  // too many digits
   TEST(!ParseVersion("00000000000000000000000000000000123", version), ());
 
   TEST(!ParseVersion("", version), ());
@@ -67,9 +64,7 @@ UNIT_TEST(LocalCountryFile_ParseVersion)
 // Checks basic functionality of LocalCountryFile.
 UNIT_TEST(LocalCountryFile_Smoke)
 {
-  CountryFile countryFile("TestCountry");
-  countryFile.SetRemoteSize(1 /* mapSize */);
-
+  CountryFile countryFile("TestCountry", 1 /* size */, "sha1");
   LocalCountryFile localFile("/test-dir", countryFile, 150309);
 
   TEST_EQUAL("/test-dir/TestCountry" DATA_FILE_EXTENSION, localFile.GetPath(MapFileType::Map), ());
@@ -93,8 +88,7 @@ UNIT_TEST(LocalCountryFile_DiskFiles)
 {
   Platform & platform = GetPlatform();
 
-  CountryFile countryFile("TestCountry");
-  countryFile.SetRemoteSize(1 /* mapSize */);
+  CountryFile countryFile("TestCountry", 1 /* size */, "sha1");
 
   for (int64_t version : {1, 150312})
   {
@@ -102,7 +96,7 @@ UNIT_TEST(LocalCountryFile_DiskFiles)
     TEST(!localFile.OnDisk(MapFileType::Map), ());
     TEST(!localFile.OnDisk(MapFileType::Diff), ());
 
-    string const mapFileName = GetFileName(countryFile.GetName(), MapFileType::Map);
+    string const mapFileName = countryFile.GetFileName(MapFileType::Map);
     string const mapFileContents("map");
     ScopedFile testMapFile(mapFileName, mapFileContents);
 

platform/platform_tests_support/scoped_file.cpp

@@ -31,9 +31,7 @@ ScopedFile::ScopedFile(std::string const & relativePath, std::string const & con
 }
 
 ScopedFile::ScopedFile(ScopedDir const & dir, CountryFile const & countryFile, MapFileType type)
-  : ScopedFile(
-        base::JoinPath(dir.GetRelativePath(), GetFileName(countryFile.GetName(), type)),
-        Mode::Create)
+: ScopedFile(base::JoinPath(dir.GetRelativePath(), countryFile.GetFileName(type)), Mode::Create)
 {
 }
 

routing/mwm_hierarchy_handler.cpp

@@ -34,7 +34,7 @@ std::string GetCountryByMwmName(std::string const & mwmName, CountryParentNameGe
       break;
 
     auto parent = fn(country);
-    if (parent == "Countries")
+    if (parent == COUNTRIES_ROOT)
       break;
     else
       country = std::move(parent);

routing/road_access_serialization.hpp

@@ -87,11 +87,7 @@ public:
     }
     default:
     {
-      LOG(LWARNING, ("Wrong roadaccess section header version:", static_cast<int>(readHeader),
-                  ". Mwm name:", mwmPath));
-      if (Platform::IsFileExistsByFullPath(mwmPath))
-        LOG(LWARNING, ("SHA1 is:", coding::SHA1::CalculateBase64(mwmPath)));
-
+      LOG(LERROR, ("Wrong RoadAccessSerializer header in", mwmPath));
       UNREACHABLE();
     }
     }
@@ -99,7 +95,7 @@ public:
 
 private:
   inline static Header const kLatestVersion = Header::WithAccessConditional;
-  
+
   class AccessPosition
   {
   public:
@@ -107,7 +103,7 @@ private:
     {
       return {featureId, 0 /* wildcard pointId for way access */};
     }
-    
+
     static AccessPosition MakePointAccess(uint32_t featureId, uint32_t pointId)
     {
       return {featureId, pointId + 1};
@@ -123,7 +119,7 @@ private:
     {
       return std::tie(m_featureId, m_pointId) < std::tie(rhs.m_featureId, rhs.m_pointId);
     }
-    
+
     uint32_t GetFeatureId() const { return m_featureId; }
     uint32_t GetPointId() const
     {

routing/routing_tests/mwm_hierarchy_test.cpp

@@ -1,8 +1,9 @@
 #include "testing/testing.hpp"
 
 #include "routing/mwm_hierarchy_handler.hpp"
-#include "storage/country_parent_getter.hpp"
 
+#include "storage/country_parent_getter.hpp"
+#include "storage/routing_helpers.hpp"
 
 using namespace routing;
 
@@ -17,14 +18,6 @@ UNIT_TEST(CountryParentGetter_Smoke)
 namespace
 {
 
-std::shared_ptr<NumMwmIds> CreateNumMwmIds(storage::CountryParentGetter const & getter)
-{
-  auto mwmIDs = std::make_shared<NumMwmIds>();
-  getter.GetStorageForTesting().ForEachCountryFile(
-      [&mwmIDs](platform::CountryFile const & file) { mwmIDs->RegisterFile(file); });
-  return mwmIDs;
-}
-
 uint16_t GetCountryID(std::shared_ptr<NumMwmIds> mwmIDs, std::string const & mwmName)
 {
   return mwmIDs->GetId(platform::CountryFile(mwmName));
@@ -35,7 +28,7 @@ uint16_t GetCountryID(std::shared_ptr<NumMwmIds> mwmIDs, std::string const & mwm
 UNIT_TEST(MwmHierarchyHandler_Smoke)
 {
   storage::CountryParentGetter getter;
-  auto mwmIDs = CreateNumMwmIds(getter);
+  auto mwmIDs = CreateNumMwmIds(getter.GetStorageForTesting());
   routing::MwmHierarchyHandler handler(mwmIDs, getter);
 
   TEST(!handler.HasCrossBorderPenalty(GetCountryID(mwmIDs, "Belarus_Maglieu Region"),

storage/country.hpp

@@ -38,7 +38,7 @@ public:
   {
   }
 
-  void SetFile(platform::CountryFile const & file) { m_file = file; }
+  void SetFile(platform::CountryFile && file) { m_file = std::move(file); }
   void SetSubtreeAttrs(MwmCounter subtreeMwmNumber, MwmSize subtreeMwmSizeBytes)
   {
     m_subtreeMwmNumber = subtreeMwmNumber;
@@ -46,12 +46,10 @@ public:
   }
   MwmCounter GetSubtreeMwmCounter() const { return m_subtreeMwmNumber; }
   MwmSize GetSubtreeMwmSizeBytes() const { return m_subtreeMwmSizeBytes; }
-  CountryId GetParent() const { return m_parent; }
 
-  /// This function valid for current logic - one file for one country (region).
-  /// If the logic will be changed, replace GetFile with ForEachFile.
   platform::CountryFile const & GetFile() const { return m_file; }
   CountryId const & Name() const { return m_name; }
+  CountryId const & GetParent() const { return m_parent; }
 
 private:
   /// Name in the country node tree. In single mwm case it's a country id.

storage/country_info_getter.cpp

@@ -148,15 +148,24 @@ m2::RectD CountryInfoGetter::CalcLimitRect(std::string const & prefix) const
 m2::RectD CountryInfoGetter::GetLimitRectForLeaf(CountryId const & leafCountryId) const
 {
   auto const it = m_countryIndex.find(leafCountryId);
-  ASSERT(it != m_countryIndex.end(), ());
-  ASSERT_LESS(it->second, m_countries.size(), ());
-  return m_countries[it->second].m_rect;
+  if (it != m_countryIndex.end())
+  {
+    ASSERT_LESS(it->second, m_countries.size(), ());
+    return m_countries[it->second].m_rect;
+  }
+  else
+  {
+    // Full rect for World files.
+    return mercator::Bounds::FullRect();
+  }
 }
 
 void CountryInfoGetter::GetMatchedRegions(std::string const & affiliation,
                                           RegionIdVec & regions) const
 {
-  CHECK(m_affiliations, ());
+  // Once set, m_affiliations ptr is never changed (same as the content).
+  ASSERT(m_affiliations, ());
+
   auto it = m_affiliations->find(affiliation);
   if (it == m_affiliations->end())
     return;

storage/country_tree.cpp

@@ -77,13 +77,8 @@ public:
   {
     Country country(id, parent);
     if (mapSize)
-    {
-      CountryFile countryFile(id);
-      countryFile.SetRemoteSize(mapSize);
-      countryFile.SetSha1(mapSha1);
-      country.SetFile(countryFile);
-    }
-    return &m_countries.AddAtDepth(depth, country);
+      country.SetFile(CountryFile{id, mapSize, mapSha1});
+    return &m_countries.AddAtDepth(depth, std::move(country));
   }
 
   void InsertOldMwmMapping(CountryId const & newId, CountryId const & oldId) override
@@ -171,13 +166,13 @@ public:
 
 // CountryTree::Node -------------------------------------------------------------------------------
 
-CountryTree::Node * CountryTree::Node::AddAtDepth(size_t level, Country const & value)
+CountryTree::Node * CountryTree::Node::AddAtDepth(size_t level, Country && value)
 {
   Node * node = this;
   while (--level > 0 && !node->m_children.empty())
     node = node->m_children.back().get();
   ASSERT_EQUAL(level, 0, ());
-  return node->Add(value);
+  return node->Add(std::move(value));
 }
 
 CountryTree::Node const & CountryTree::Node::Parent() const
@@ -253,9 +248,9 @@ void CountryTree::Node::ForEachAncestorExceptForTheRoot(
   m_parent->ForEachAncestorExceptForTheRoot(f);
 }
 
-CountryTree::Node * CountryTree::Node::Add(Country const & value)
+CountryTree::Node * CountryTree::Node::Add(Country && value)
 {
-  m_children.emplace_back(std::make_unique<Node>(value, this));
+  m_children.emplace_back(std::make_unique<Node>(std::move(value), this));
   return m_children.back().get();
 }
 
@@ -273,22 +268,22 @@ CountryTree::Node & CountryTree::GetRoot()
   return *m_countryTree;
 }
 
-Country & CountryTree::AddAtDepth(size_t level, Country const & value)
+Country & CountryTree::AddAtDepth(size_t level, Country && value)
 {
   Node * added = nullptr;
   if (level == 0)
   {
     ASSERT(IsEmpty(), ());
-    m_countryTree = std::make_unique<Node>(value, nullptr);  // Creating the root node.
+    m_countryTree = std::make_unique<Node>(std::move(value), nullptr);  // Creating the root node.
     added = m_countryTree.get();
   }
   else
   {
-    added = m_countryTree->AddAtDepth(level, value);
+    added = m_countryTree->AddAtDepth(level, std::move(value));
   }
 
   ASSERT(added, ());
-  m_countryTreeMap.insert(make_pair(value.Name(), added));
+  m_countryTreeMap.insert(make_pair(added->Value().Name(), added));
   return added->Value();
 }
 
@@ -450,9 +445,47 @@ int64_t LoadCountriesFromFile(string const & path, CountryTree & countries,
                               MwmTopCountryGeoIds & mwmTopCountryGeoIds)
 {
   string json;
-  ReaderPtr<Reader>(GetPlatform().GetReader(path)).ReadAsString(json);
-  return LoadCountriesFromBuffer(json, countries, affiliations, countryNameSynonyms,
-                                 mwmTopCityGeoIds, mwmTopCountryGeoIds);
+  int64_t version = -1;
+
+  // Basically, we choose latest version from "resource" or "writable".
+  // w > r in case of autoupdates
+  // r > w in case of new countries file with updated app
+
+  auto & pl = GetPlatform();
+  auto reader = pl.GetReaderSafe(path, "fr");
+  if (reader)
+  {
+    reader->ReadAsString(json);
+    version = LoadCountriesFromBuffer(json, countries, affiliations, countryNameSynonyms,
+                                      mwmTopCityGeoIds, mwmTopCountryGeoIds);
+  }
+
+  reader = pl.GetReaderSafe(path, "w");
+  if (reader)
+  {
+    CountryTree newCountries;
+    Affiliations newAffs;
+    CountryNameSynonyms newSyms;
+    MwmTopCityGeoIds newCityIds;
+    MwmTopCountryGeoIds newCountryIds;
+
+    reader->ReadAsString(json);
+    int64_t const newVersion = LoadCountriesFromBuffer(json, newCountries, newAffs, newSyms,
+                                                       newCityIds, newCountryIds);
+
+    if (newVersion > version)
+    {
+      version = newVersion;
+
+      countries = std::move(newCountries);
+      affiliations = std::move(newAffs);
+      countryNameSynonyms = std::move(newSyms);
+      mwmTopCityGeoIds = std::move(newCityIds);
+      mwmTopCountryGeoIds = std::move(newCountryIds);
+    }
+  }
+
+  return version;
 }
 
 void LoadCountryFile2CountryInfo(string const & jsonBuffer, map<string, CountryInfo> & id2info)

storage/country_tree.hpp

@@ -29,7 +29,7 @@ public:
   public:
     using NodeCallback = std::function<void(Node const &)>;
 
-    Node(Country const & value, Node * parent) : m_value(value), m_parent(parent) {}
+    Node(Country && value, Node * parent) : m_value(std::move(value)), m_parent(parent) {}
 
     Country const & Value() const { return m_value; }
     Country & Value() { return m_value; }
@@ -43,7 +43,7 @@ public:
     /// \param value is a value of node which will be added.
     /// \note This method does not let to add a node to an arbitrary place in the tree.
     /// It's posible to add children only from "right side".
-    Node * AddAtDepth(size_t level, Country const & value);
+    Node * AddAtDepth(size_t level, Country && value);
 
     bool HasParent() const { return m_parent != nullptr; }
 
@@ -74,7 +74,7 @@ public:
     void ForEachAncestorExceptForTheRoot(NodeCallback const & f) const;
 
   private:
-    Node * Add(Country const & value);
+    Node * Add(Country && value);
 
     Country m_value;
 
@@ -91,7 +91,7 @@ public:
 
   Node & GetRoot();
 
-  Country & AddAtDepth(size_t level, Country const & value);
+  Country & AddAtDepth(size_t level, Country && value);
 
   /// Deletes all children and makes tree empty
   void Clear();

storage/queued_country.cpp

@@ -53,7 +53,7 @@ CountryId const & QueuedCountry::GetCountryId() const
 
 std::string QueuedCountry::GetRelativeUrl() const
 {
-  auto const fileName = platform::GetFileName(m_countryFile.GetName(), m_fileType);
+  auto const fileName = m_countryFile.GetFileName(m_fileType);
 
   uint64_t diffVersion = 0;
   if (m_fileType == MapFileType::Diff)

storage/routing_helpers.cpp

@@ -1,13 +1,14 @@
 #include "storage/routing_helpers.hpp"
 
-#include <memory>
+namespace routing
+{
 
 std::unique_ptr<m4::Tree<routing::NumMwmId>> MakeNumMwmTree(
-    routing::NumMwmIds const & numMwmIds, storage::CountryInfoGetter const & countryInfoGetter)
+    NumMwmIds const & numMwmIds, storage::CountryInfoGetter const & countryInfoGetter)
 {
-  auto tree = std::make_unique<m4::Tree<routing::NumMwmId>>();
+  auto tree = std::make_unique<m4::Tree<NumMwmId>>();
 
-  numMwmIds.ForEachId([&](routing::NumMwmId numMwmId) {
+  numMwmIds.ForEachId([&](NumMwmId numMwmId) {
     auto const & countryName = numMwmIds.GetFile(numMwmId).GetName();
     tree->Add(numMwmId, countryInfoGetter.GetLimitRectForLeaf(countryName));
   });
@@ -18,7 +19,11 @@ std::unique_ptr<m4::Tree<routing::NumMwmId>> MakeNumMwmTree(
 std::shared_ptr<routing::NumMwmIds> CreateNumMwmIds(storage::Storage const & storage)
 {
   auto numMwmIds = std::make_shared<routing::NumMwmIds>();
-  storage.ForEachCountryFile(
-      [&](platform::CountryFile const & file) { numMwmIds->RegisterFile(file); });
+  storage.ForEachCountry([&](storage::Country const & country)
+  {
+    numMwmIds->RegisterFile(country.GetFile());
+  });
   return numMwmIds;
 }
+
+} // namespace routing

storage/routing_helpers.hpp

@@ -9,6 +9,9 @@
 
 #include <memory>
 
+namespace routing
+{
 std::unique_ptr<m4::Tree<routing::NumMwmId>> MakeNumMwmTree(
-    routing::NumMwmIds const & numMwmIds, storage::CountryInfoGetter const & countryInfoGetter);
-std::shared_ptr<routing::NumMwmIds> CreateNumMwmIds(storage::Storage const & storage);
+    NumMwmIds const & numMwmIds, storage::CountryInfoGetter const & countryInfoGetter);
+std::shared_ptr<NumMwmIds> CreateNumMwmIds(storage::Storage const & storage);
+} // namespace routing

storage/storage.cpp

@@ -245,9 +245,9 @@ void Storage::RegisterAllLocalMaps(bool enableDiffs)
 
     LocalCountryFile const & localFile = *i;
     string const & name = localFile.GetCountryName();
-    CountryId countryId = FindCountryIdByFile(name);
+    CountryId const countryId = FindCountryIdByFile(name);
     if (IsLeaf(countryId))
-      RegisterCountryFiles(countryId, localFile.GetDirectory(), localFile.GetVersion());
+      RegisterCountryFiles(countryId, localFile);
     else
       RegisterFakeCountryFiles(localFile);
 
@@ -257,8 +257,9 @@ void Storage::RegisterAllLocalMaps(bool enableDiffs)
   }
 
   FindAllDiffs(m_dataDir, m_notAppliedDiffs);
-  if (enableDiffs)
-    LoadDiffScheme();
+  //if (enableDiffs)
+  //  LoadDiffScheme();
+
   // Note: call order is important, diffs loading must be called first.
   // Since diffs info downloading and servers list downloading
   // are working on network thread, consecutive executing is guaranteed.
@@ -270,7 +271,10 @@ void Storage::GetLocalMaps(vector<LocalFilePtr> & maps) const
   CHECK_THREAD_CHECKER(m_threadChecker, ());
 
   for (auto const & p : m_localFiles)
-    maps.push_back(GetLatestLocalFile(p.first));
+  {
+    if (!IsResourceID(p.first))
+      maps.push_back(GetLatestLocalFile(p.first));
+  }
 
   for (auto const & p : m_localFilesForFakeCountries)
     maps.push_back(p.second);
@@ -701,32 +705,39 @@ void Storage::RegisterDownloadedFiles(CountryId const & countryId, MapFileType t
     ApplyDiff(countryId, fn);
     return;
   }
+  ASSERT_EQUAL(type, MapFileType::Map, ());
 
   CountryFile const countryFile = GetCountryFile(countryId);
   LocalFilePtr localFile = GetLocalFile(countryId, GetCurrentDataVersion());
-  if (!localFile)
+
+  if (!localFile || localFile->GetDirectoryType() == LocalCountryFile::BUNDLE)
     localFile = PreparePlaceForCountryFiles(GetCurrentDataVersion(), m_dataDir, countryFile);
+  else
+  {
+    /// @todo If localFile already exists, we will remove it from disk below?
+    LOG(LERROR, ("Downloaded country file for already existing one", *localFile));
+  }
+
   if (!localFile)
   {
-    LOG(LERROR, ("Local file data structure can't be prepared for downloaded file(", countryFile,
-                 type, ")."));
-    fn(false /* isSuccess */);
+    LOG(LERROR, ("Can't prepare LocalCountryFile for", countryFile, "in folder", m_dataDir));
+    fn(false);
     return;
   }
 
   string const path = GetFileDownloadPath(countryId, type);
   if (!base::RenameFileX(path, localFile->GetPath(type)))
   {
+    /// @todo If localFile already exists (valid), remove it from disk and return false?
     localFile->DeleteFromDisk(type);
     fn(false);
     return;
   }
 
-  static string const kSourceKey = "map";
   if (m_integrityValidationEnabled && !localFile->ValidateIntegrity())
   {
-    base::DeleteFileX(localFile->GetPath(MapFileType::Map));
-    fn(false /* isSuccess */);
+    UNUSED_VALUE(base::DeleteFileX(localFile->GetPath(type)));
+    fn(false);
     return;
   }
 
@@ -777,13 +788,9 @@ void Storage::GetOutdatedCountries(vector<Country const *> & countries) const
   for (auto const & p : m_localFiles)
   {
     CountryId const & countryId = p.first;
-    string const name = GetCountryFile(countryId).GetName();
     LocalFilePtr file = GetLatestLocalFile(countryId);
-    if (file && file->GetVersion() != GetCurrentDataVersion() && name != WORLD_COASTS_FILE_NAME
-        && name != WORLD_FILE_NAME)
-    {
+    if (file && file->GetVersion() != GetCurrentDataVersion())
       countries.push_back(&CountryLeafByCountryId(countryId));
-    }
   }
 }
 
@@ -860,23 +867,21 @@ void Storage::RegisterCountryFiles(LocalFilePtr localFile)
   }
 }
 
-void Storage::RegisterCountryFiles(CountryId const & countryId, string const & directory,
-                                   int64_t version)
+void Storage::RegisterCountryFiles(CountryId const & countryId, LocalCountryFile const & localFile)
 {
-  LocalFilePtr localFile = GetLocalFile(countryId, version);
-  if (localFile)
-    return;
-
-  CountryFile const & countryFile = GetCountryFile(countryId);
-  localFile = make_shared<LocalCountryFile>(directory, countryFile, version);
-  RegisterCountryFiles(localFile);
+  LocalFilePtr p = GetLocalFile(countryId, localFile.GetVersion());
+  if (!p)
+  {
+    p = make_shared<LocalCountryFile>(localFile);
+    RegisterCountryFiles(p);
+  }
 }
 
-void Storage::RegisterFakeCountryFiles(platform::LocalCountryFile const & localFile)
+void Storage::RegisterFakeCountryFiles(LocalCountryFile const & localFile)
 {
-  LocalFilePtr fakeCountryLocalFile = make_shared<LocalCountryFile>(localFile);
-  fakeCountryLocalFile->SyncWithDisk();
-  m_localFilesForFakeCountries[fakeCountryLocalFile->GetCountryFile()] = fakeCountryLocalFile;
+  LocalFilePtr p = make_shared<LocalCountryFile>(localFile);
+  p->SyncWithDisk();
+  m_localFilesForFakeCountries[p->GetCountryFile()] = p;
 }
 
 void Storage::DeleteCountryFiles(CountryId const & countryId, MapFileType type, bool deferredDelete)
@@ -987,7 +992,7 @@ int64_t Storage::ParseIndexAndGetDataVersion(std::string const & index) const
       return 0;
 
     /// @todo Get correct value somehow ..
-    int64_t const appVersion = 21042001;
+    int64_t const appVersion = 21072001;
     int64_t dataVersion = 0;
 
     size_t const count = json_array_size(root);
@@ -1036,14 +1041,17 @@ void Storage::ApplyCountries(std::string const & countriesBuffer, Storage & stor
   m_downloader->SetDataVersion(m_currentVersion);
 
   m_countries = std::move(storage.m_countries);
-  m_affiliations = std::move(storage.m_affiliations);
-  m_countryNameSynonyms = std::move(storage.m_countryNameSynonyms);
-  m_mwmTopCityGeoIds = std::move(storage.m_mwmTopCityGeoIds);
-  m_mwmTopCountryGeoIds = std::move(storage.m_mwmTopCountryGeoIds);
+
+  // Do not to update this information containers to avoid possible races.
+  // Affiliations, synonyms, etc can be updated with the app update.
+  //m_affiliations = std::move(storage.m_affiliations);
+  //m_countryNameSynonyms = std::move(storage.m_countryNameSynonyms);
+  //m_mwmTopCityGeoIds = std::move(storage.m_mwmTopCityGeoIds);
+  //m_mwmTopCountryGeoIds = std::move(storage.m_mwmTopCountryGeoIds);
 
   LOG(LDEBUG, ("Version", m_currentVersion, "is applied"));
 
-  LoadDiffScheme();
+  //LoadDiffScheme();
 
   /// @todo Start World and WorldCoasts download ?!
 }
@@ -1071,6 +1079,7 @@ void Storage::GetChildren(CountryId const & parent, CountriesVec & childIds) con
     childIds.emplace_back(parentNode->Child(i).Value().Name());
 }
 
+/*
 void Storage::GetLocalRealMaps(CountriesVec & localMaps) const
 {
   CHECK_THREAD_CHECKER(m_threadChecker, ());
@@ -1081,6 +1090,7 @@ void Storage::GetLocalRealMaps(CountriesVec & localMaps) const
   for (auto const & keyValue : m_localFiles)
     localMaps.push_back(keyValue.first);
 }
+*/
 
 void Storage::GetChildrenInGroups(CountryId const & parent, CountriesVec & downloadedChildren,
                                   CountriesVec & availChildren, bool keepAvailableChildren) const
@@ -1239,6 +1249,19 @@ bool Storage::IsDisputed(CountryTree::Node const & node) const
   return found.size() > 1;
 }
 
+bool Storage::IsRealCountryLeaf(CountryTree::Node const & node)
+{
+  if (node.ChildrenCount() != 0)
+    return false;
+
+  return !IsResourceID(node.Value().Name());
+}
+
+bool Storage::IsResourceID(CountryId const & countryId)
+{
+  return countryId == RESOURCES_FILE_NAME;
+}
+
 void Storage::CalcMaxMwmSizeBytes()
 {
   m_maxMwmSizeBytes = 0;
@@ -1252,6 +1275,7 @@ void Storage::CalcMaxMwmSizeBytes()
   });
 }
 
+/*
 void Storage::LoadDiffScheme()
 {
   CHECK_THREAD_CHECKER(m_threadChecker, ());
@@ -1281,6 +1305,7 @@ void Storage::LoadDiffScheme()
     OnDiffStatusReceived(move(diffs));
   });
 }
+*/
 
 void Storage::ApplyDiff(CountryId const & countryId, function<void(bool isSuccess)> const & fn)
 {
@@ -1312,9 +1337,9 @@ void Storage::ApplyDiff(CountryId const & countryId, function<void(bool isSucces
   LocalFilePtr & diffFile = params.m_diffFile;
   diffs::ApplyDiff(
       move(params), *emplaceResult.first->second,
-      [this, fn, countryId, diffFile](DiffApplicationResult result) {
+      [this, fn, countryId, diffFile](DiffApplicationResult result)
+      {
         CHECK_THREAD_CHECKER(m_threadChecker, ());
-        static string const kSourceKey = "diff";
         if (result == DiffApplicationResult::Ok && m_integrityValidationEnabled &&
             !diffFile->ValidateIntegrity())
         {
@@ -1376,6 +1401,7 @@ void Storage::AbortDiffScheme()
   m_diffsDataSource->AbortDiffScheme();
 }
 
+/*
 bool Storage::IsPossibleToAutoupdate() const
 {
   CHECK_THREAD_CHECKER(m_threadChecker, ());
@@ -1398,6 +1424,7 @@ bool Storage::IsPossibleToAutoupdate() const
 
   return true;
 }
+*/
 
 void Storage::SetStartDownloadingCallback(StartDownloadingCallback const & cb)
 {
@@ -1515,8 +1542,6 @@ void Storage::GetNodeAttrs(CountryId const & countryId, NodeAttrs & nodeAttrs) c
   nodeAttrs.m_status = statusAndErr.status;
   nodeAttrs.m_error = statusAndErr.error;
   nodeAttrs.m_nodeLocalName = m_countryNameGetter(countryId);
-  nodeAttrs.m_nodeLocalDescription =
-      m_countryNameGetter.Get(countryId + LOCALIZATION_DESCRIPTION_SUFFIX);
 
   // Progress.
   if (nodeAttrs.m_status == NodeStatus::OnDisk)
@@ -1541,11 +1566,11 @@ void Storage::GetNodeAttrs(CountryId const & countryId, NodeAttrs & nodeAttrs) c
   nodeAttrs.m_downloadingMwmCounter = 0;
   nodeAttrs.m_downloadingMwmSize = 0;
   CountriesSet visitedLocalNodes;
-  node->ForEachInSubtree([this, &nodeAttrs, &visitedLocalNodes](CountryTree::Node const & d) {
-    CountryId const countryId = d.Value().Name();
-    if (visitedLocalNodes.count(countryId) != 0)
+  node->ForEachInSubtree([this, &nodeAttrs, &visitedLocalNodes](CountryTree::Node const & d)
+  {
+    CountryId const & countryId = d.Value().Name();
+    if (!visitedLocalNodes.insert(countryId).second)
       return;
-    visitedLocalNodes.insert(countryId);
 
     // Downloading mwm information.
     StatusAndError const statusAndErr = GetNodeStatus(d);
@@ -1728,20 +1753,38 @@ bool Storage::GetUpdateInfo(CountryId const & countryId, UpdateInfo & updateInfo
   return true;
 }
 
+/// @note No need to call CHECK_THREAD_CHECKER(m_threadChecker, ()) here and below, because
+/// we don't change all this containers during update. Consider checking, otherwise.
+/// @{
+Affiliations const * Storage::GetAffiliations() const
+{
+  return &m_affiliations;
+}
+
+CountryNameSynonyms const & Storage::GetCountryNameSynonyms() const
+{
+  return m_countryNameSynonyms;
+}
+
+MwmTopCityGeoIds const & Storage::GetMwmTopCityGeoIds() const
+{
+  return m_mwmTopCityGeoIds;
+}
+
 std::vector<base::GeoObjectId> Storage::GetTopCountryGeoIds(CountryId const & countryId) const
 {
   std::vector<base::GeoObjectId> result;
 
-  auto const collector = [this, &result](CountryId const & id, CountryTree::Node const &) {
+  ForEachAncestorExceptForTheRoot(countryId, [this, &result](CountryId const & id, CountryTree::Node const &)
+  {
     auto const it = m_mwmTopCountryGeoIds.find(id);
     if (it != m_mwmTopCountryGeoIds.cend())
       result.insert(result.end(), it->second.cbegin(), it->second.cend());
-  };
-
-  ForEachAncestorExceptForTheRoot(countryId, collector);
+  });
 
   return result;
 }
+/// @}
 
 void Storage::GetQueuedChildren(CountryId const & parent, CountriesVec & queuedChildren) const
 {

storage/storage.hpp

@@ -83,10 +83,6 @@ struct NodeAttrs
   /// a device locale.
   std::string m_nodeLocalName;
 
-  /// The description of the node in a local language. That means the language dependent on
-  /// a device locale.
-  std::string m_nodeLocalDescription;
-
   /// Node id and local name of the parents of the node.
   /// For the root |m_parentInfo| is empty.
   /// Locale language is a language set by Storage::SetLocale().
@@ -174,10 +170,11 @@ private:
   /// stores countries whose download has failed recently
   CountriesSet m_failedCountries;
 
+  /// @todo Do we really store a list of local files here (of different versions)?
+  /// I suspect that only one at a time, old versions are deleted automatically.
   std::map<CountryId, std::list<LocalFilePtr>> m_localFiles;
 
-  // Our World.mwm and WorldCoasts.mwm are fake countries, together with any custom mwm in data
-  // folder.
+  // World and WorldCoasts are fake countries, together with any custom mwm in data folder.
   std::map<platform::CountryFile, LocalFilePtr> m_localFilesForFakeCountries;
 
   // Since the diffs applying runs on a different thread, the result
@@ -230,16 +227,21 @@ private:
 
   CountryNameGetter m_countryNameGetter;
 
-  // |m_affiliations| is a mapping from countryId to the list of names of
-  // geographical objects (such as countries) that encompass this countryId.
-  // Note. Affiliations is inherited from ancestors of the countryId in country tree.
-  // |m_affiliations| is filled during Storage initialization or during migration process.
-  // It is filled with data of countries.txt (field "affiliations").
-  // Once filled |m_affiliations| is not changed.
+  /**
+   * @brief Mapping from countryId to the list of names of
+   * geographical objects (such as countries) that encompass this countryId.
+   * @note Affiliations are inherited from ancestors of the countryId in country tree.
+   * Initialized with data of countries.txt (field "affiliations").
+   * Once filled, they are not changed.
+   */
   Affiliations m_affiliations;
   CountryNameSynonyms m_countryNameSynonyms;
+
+  /// @todo This containers are empty for now, but probably will be used in future.
+  /// @{
   MwmTopCityGeoIds m_mwmTopCityGeoIds;
   MwmTopCountryGeoIds m_mwmTopCountryGeoIds;
+  /// @}
 
   MwmSize m_maxMwmSizeBytes = 0;
 
@@ -432,22 +434,23 @@ public:
   /// \return true if updateInfo is filled correctly and false otherwise.
   bool GetUpdateInfo(CountryId const & countryId, UpdateInfo & updateInfo) const;
 
-  Affiliations const & GetAffiliations() const { return m_affiliations; }
-
-  CountryNameSynonyms const & GetCountryNameSynonyms() const { return m_countryNameSynonyms; }
-
-  MwmTopCityGeoIds const & GetMwmTopCityGeoIds() const { return m_mwmTopCityGeoIds; }
+  /// @name This functions should be called from 'main' thread only to avoid races.
+  /// @{
+  /// @return Pointer that will be stored for later use.
+  Affiliations const * GetAffiliations() const;
+  CountryNameSynonyms const & GetCountryNameSynonyms() const;
+  MwmTopCityGeoIds const & GetMwmTopCityGeoIds() const;
   std::vector<base::GeoObjectId> GetTopCountryGeoIds(CountryId const & countryId) const;
+  /// @}
 
-  /// \brief Calls |toDo| for each node for subtree with |root|.
-  /// For example ForEachInSubtree(GetRootId()) calls |toDo| for every node including
-  /// the result of GetRootId() call.
+  /// For each node with \a root subtree (including).
   template <class ToDo>
   void ForEachInSubtree(CountryId const & root, ToDo && toDo) const;
   template <class ToDo>
   void ForEachAncestorExceptForTheRoot(CountryId const & childId, ToDo && toDo) const;
   template <class ToDo>
-  void ForEachCountryFile(ToDo && toDo) const;
+  /// For each leaf country excluding Worlds.
+  void ForEachCountry(ToDo && toDo) const;
 
   /// \brief Sets callback which will be called in case of a click on download map button on the map.
   void SetCallbackForClickOnDownloadMap(DownloadFn & downloadFn);
@@ -461,7 +464,7 @@ public:
 
   /// \returns real (not fake) local maps contained in countries.txt.
   /// So this method does not return custom user local maps and World and WorldCoasts country id.
-  void GetLocalRealMaps(CountriesVec & localMaps) const;
+  //void GetLocalRealMaps(CountriesVec & localMaps) const;
 
   /// Do we have downloaded countries
   bool HaveDownloadedCountries() const;
@@ -501,7 +504,7 @@ public:
   // Returns true iff |countryId| exists as a node in the tree.
   bool IsNode(CountryId const & countryId) const;
 
-  // Returns true iff |countryId| is a leaf of the tree.
+  /// @return true iff \a countryId is a leaf of the tree.
   bool IsLeaf(CountryId const & countryId) const;
 
   // Returns true iff |countryId| is an inner node of the tree.
@@ -547,9 +550,8 @@ public:
   void SetDownloadingServersForTesting(std::vector<std::string> const & downloadingUrls);
   void SetLocaleForTesting(std::string const & jsonBuffer, std::string const & locale);
 
-  /// Returns true if the diff scheme is available and all local outdated maps can be updated via
-  /// diffs.
-  bool IsPossibleToAutoupdate() const;
+  /// Returns true if the diff scheme is available and all local outdated maps can be updated via diffs.
+  //bool IsPossibleToAutoupdate() const;
 
   void SetStartDownloadingCallback(StartDownloadingCallback const & cb);
 
@@ -580,8 +582,7 @@ private:
 
   // Registers disk files for a country. This method must be used only
   // for real (listed in countries.txt) countries.
-  void RegisterCountryFiles(CountryId const & countryId, std::string const & directory,
-                            int64_t version);
+  void RegisterCountryFiles(CountryId const & countryId, platform::LocalCountryFile const & localFile);
 
   // Registers disk files for a country. This method must be used only
   // for custom (made by user) map files.
@@ -602,6 +603,7 @@ private:
 
   /// Returns status for a node (group node or not).
   StatusAndError GetNodeStatus(CountryTree::Node const & node) const;
+
   /// Returns status for a node (group node or not).
   /// Fills |disputedTeritories| with all disputed teritories in subtree with the root == |node|.
   StatusAndError GetNodeStatusInfo(
@@ -624,14 +626,18 @@ private:
   void ForEachAncestorExceptForTheRoot(std::vector<CountryTree::Node const *> const & nodes,
                                        ToDo && toDo) const;
 
-  /// Returns true if |node.Value().Name()| is a disputed territory and false otherwise.
+  /// @return true if |node.Value().Name()| is a disputed territory and false otherwise.
   bool IsDisputed(CountryTree::Node const & node) const;
 
+  /// @return true iff \a node is a country MWM leaf of the tree.
+  static bool IsRealCountryLeaf(CountryTree::Node const & node);
+  static bool IsResourceID(CountryId const & countryId);
+
   void CalcMaxMwmSizeBytes();
 
   void OnMapDownloadFailed(CountryId const & countryId);
 
-  void LoadDiffScheme();
+  //void LoadDiffScheme();
   void ApplyDiff(CountryId const & countryId, std::function<void(bool isSuccess)> const & fn);
 
   using IsDiffAbsentForCountry = std::function<bool(CountryId const & id)>;
@@ -702,11 +708,12 @@ void Storage::ForEachAncestorExceptForTheRoot(std::vector<CountryTree::Node cons
 }
 
 template <class ToDo>
-void Storage::ForEachCountryFile(ToDo && toDo) const
+void Storage::ForEachCountry(ToDo && toDo) const
 {
-  m_countries.GetRoot().ForEachInSubtree([&](CountryTree::Node const & node) {
-    if (node.ChildrenCount() == 0)
-      toDo(node.Value().GetFile());
+  m_countries.GetRoot().ForEachInSubtree([&](CountryTree::Node const & node)
+  {
+    if (IsRealCountryLeaf(node))
+      toDo(node.Value());
   });
 }
 }  // namespace storage

storage/storage_tests/CMakeLists.txt

@@ -1,6 +1,7 @@
 project(storage_tests)
 
 set(SRC
+  countries_tests.cpp
   country_info_getter_tests.cpp
   country_name_getter_tests.cpp
   downloader_tests.cpp

storage/storage_tests/countries_tests.cpp

@@ -0,0 +1,14 @@
+#include "testing/testing.hpp"
+
+#include "platform/platform.hpp"
+
+#include "coding/sha1.hpp"
+
+#include <iostream>
+
+UNIT_TEST(CalculateWorldSHA)
+{
+  auto const path = GetPlatform().ResourcesDir();
+  for (char const * country : { WORLD_FILE_NAME, WORLD_COASTS_FILE_NAME })
+    std::cout << coding::SHA1::CalculateBase64(path + country + DATA_FILE_EXTENSION) << std::endl;
+}

storage/storage_tests/country_info_getter_tests.cpp

@@ -243,9 +243,9 @@ UNIT_TEST(CountryInfoGetter_Countries_And_Polygons)
 
   // Set is used here because disputed territories may occur as leaves several times.
   set<CountryId> storageLeaves;
-  storage.ForEachInSubtree(storage.GetRootId(), [&](CountryId const & countryId, bool groupNode) {
-    if (!groupNode)
-      storageLeaves.insert(countryId);
+  storage.ForEachCountry([&](Country const & country)
+  {
+    storageLeaves.insert(country.Name());
   });
 
   TEST_EQUAL(countries.size(), storageLeaves.size(), ());

storage/storage_tests/storage_tests.cpp

@@ -515,8 +515,7 @@ UNIT_TEST(StorageTest_Smoke)
   CountryId const georgiaCountryId = storage.FindCountryIdByFile("Georgia");
   TEST(IsCountryIdValid(georgiaCountryId), ());
   CountryFile usaGeorgiaFile = storage.GetCountryFile(georgiaCountryId);
-  TEST_EQUAL(platform::GetFileName(usaGeorgiaFile.GetName(), MapFileType::Map),
-             "Georgia" DATA_FILE_EXTENSION, ());
+  TEST_EQUAL(usaGeorgiaFile.GetFileName(MapFileType::Map), "Georgia" DATA_FILE_EXTENSION, ());
 }
 
 UNIT_CLASS_TEST(StorageTest, CountryDownloading)
@@ -716,7 +715,7 @@ UNIT_TEST(StorageTest_GetRootId)
                          })"), make_unique<TestMapFilesDownloader>());
 
   // The name of the root is the same for courntries.txt version 1 and version 2.
-  TEST_EQUAL(storage.GetRootId(), "Countries", ());
+  TEST_EQUAL(storage.GetRootId(), COUNTRIES_ROOT, ());
 }
 
 UNIT_TEST(StorageTest_GetChildren)
@@ -724,7 +723,7 @@ UNIT_TEST(StorageTest_GetChildren)
   Storage storage(kCountriesTxt, make_unique<TestMapFilesDownloader>());
 
   CountryId const world = storage.GetRootId();
-  TEST_EQUAL(world, "Countries", ());
+  TEST_EQUAL(world, COUNTRIES_ROOT, ());
 
   CountriesVec countriesList;
   storage.GetChildren(world, countriesList);
@@ -748,16 +747,16 @@ UNIT_TEST(StorageTest_GetAffiliations)
 
   vector<string> const abkhaziaId = {"Abkhazia"};
   for (auto const & s : {"Georgia", "Russia", "Europe"})
-    TEST_EQUAL(storage.GetAffiliations().at(s), abkhaziaId, ());
+    TEST_EQUAL(storage.GetAffiliations()->at(s), abkhaziaId, ());
 
   // Affiliation inheritance.
   vector<string> const disputableId = {"Disputable Territory"};
   for (auto const & s : {"Stepchild Land1", "Stepchild Land2"})
-    TEST_EQUAL(storage.GetAffiliations().at(s), disputableId, ());
+    TEST_EQUAL(storage.GetAffiliations()->at(s), disputableId, ());
 
   vector<string> const indisputableId = {"Indisputable Territory Of Country1"};
   for (auto const & s : {"Child Land1"})
-    TEST_EQUAL(storage.GetAffiliations().at(s), indisputableId, ());
+    TEST_EQUAL(storage.GetAffiliations()->at(s), indisputableId, ());
 }
 
 UNIT_TEST(StorageTest_HasCountryId)
@@ -799,31 +798,33 @@ UNIT_CLASS_TEST(StorageTest, DownloadedMap)
   }
 
   // Storage::GetLocalRealMaps() test.
+  /*
   CountriesVec localRealMaps;
   storage.GetLocalRealMaps(localRealMaps);
-  sort(localRealMaps.begin(), localRealMaps.end());
+  TEST_EQUAL(localRealMaps.size(), 4, ());
 
   TEST(storage.IsNodeDownloaded("Algeria_Central"), ());
   TEST(storage.IsNodeDownloaded("Algeria_Coast"), ());
   TEST(!storage.IsNodeDownloaded("Algeria_Coast.mwm"), ());
-  TEST(!storage.IsNodeDownloaded("World"), ());
-  TEST(!storage.IsNodeDownloaded("World"), ());
+  TEST(!storage.IsNodeDownloaded(WORLD_FILE_NAME), ());
+  TEST(!storage.IsNodeDownloaded(WORLD_COASTS_FILE_NAME), ());
+  */
 
   // Storage::GetChildrenInGroups test when at least Algeria_Central and Algeria_Coast have been downloaded.
   CountryId const rootCountryId = storage.GetRootId();
-  TEST_EQUAL(rootCountryId, "Countries", ());
+  TEST_EQUAL(rootCountryId, COUNTRIES_ROOT, ());
 
   CountriesVec downloaded, available;
   CountriesVec downloadedWithKeep, availableWithKeep;
 
   storage.GetChildrenInGroups(rootCountryId, downloaded, available);
   TEST_EQUAL(downloaded.size(), 1, (downloaded));
-  TEST_EQUAL(available.size(), 223, ());
+  TEST_EQUAL(available.size(), 225, ());
 
   storage.GetChildrenInGroups(rootCountryId, downloadedWithKeep,
                               availableWithKeep, true /* keepAvailableChildren*/);
   TEST_EQUAL(downloadedWithKeep.size(), 1, (downloadedWithKeep));
-  TEST_EQUAL(availableWithKeep.size(), 224, ());
+  TEST_EQUAL(availableWithKeep.size(), 226, ());
 
   storage.GetChildrenInGroups("Algeria", downloaded, available);
   TEST_EQUAL(downloaded.size(), 2, (downloaded));
@@ -911,10 +912,10 @@ UNIT_TEST(StorageTest_ParentSingleMwm)
 {
   Storage storage(kCountriesTxt, make_unique<TestMapFilesDownloader>());
 
-  TEST(ParentOf(storage, "Countries", "Abkhazia"), ());
+  TEST(ParentOf(storage, COUNTRIES_ROOT, "Abkhazia"), ());
   TEST(ParentOf(storage, "Algeria", "Algeria_Central"), ());
-  TEST(ParentOf(storage, "Countries", "South Korea_South"), ());
-  TEST(ParentOf(storage, kInvalidCountryId, "Countries"), ());
+  TEST(ParentOf(storage, COUNTRIES_ROOT, "South Korea_South"), ());
+  TEST(ParentOf(storage, kInvalidCountryId, COUNTRIES_ROOT), ());
 }
 
 UNIT_TEST(StorageTest_GetNodeStatusesSingleMwm)
@@ -944,7 +945,7 @@ UNIT_TEST(StorageTest_GetNodeAttrsSingleMwm)
   TEST_EQUAL(nodeAttrs.m_status, NodeStatus::NotDownloaded, ());
   TEST_EQUAL(nodeAttrs.m_error, NodeErrorCode::NoError, ());
   TEST_EQUAL(nodeAttrs.m_parentInfo.size(), 1, ());
-  TEST_EQUAL(nodeAttrs.m_parentInfo[0].m_id, "Countries", ());
+  TEST_EQUAL(nodeAttrs.m_parentInfo[0].m_id, COUNTRIES_ROOT, ());
   TEST_EQUAL(nodeAttrs.m_downloadingProgress.m_bytesDownloaded, 0, ());
   TEST_EQUAL(nodeAttrs.m_downloadingProgress.m_bytesTotal, 0, ());
   TEST_EQUAL(nodeAttrs.m_localMwmCounter, 0, ());
@@ -959,7 +960,7 @@ UNIT_TEST(StorageTest_GetNodeAttrsSingleMwm)
   TEST_EQUAL(nodeAttrs.m_status, NodeStatus::NotDownloaded, ()); // It's a status of expandable node.
   TEST_EQUAL(nodeAttrs.m_error, NodeErrorCode::NoError, ());
   TEST_EQUAL(nodeAttrs.m_parentInfo.size(), 1, ());
-  TEST_EQUAL(nodeAttrs.m_parentInfo[0].m_id, "Countries", ());
+  TEST_EQUAL(nodeAttrs.m_parentInfo[0].m_id, COUNTRIES_ROOT, ());
   TEST_EQUAL(nodeAttrs.m_downloadingProgress.m_bytesDownloaded, 0, ());
   TEST_EQUAL(nodeAttrs.m_downloadingProgress.m_bytesTotal, 0, ());
   TEST_EQUAL(nodeAttrs.m_localMwmCounter, 0, ());
@@ -989,7 +990,7 @@ UNIT_TEST(StorageTest_GetNodeAttrsSingleMwm)
   TEST_EQUAL(nodeAttrs.m_status, NodeStatus::NotDownloaded, ());
   TEST_EQUAL(nodeAttrs.m_error, NodeErrorCode::NoError, ());
   TEST_EQUAL(nodeAttrs.m_parentInfo.size(), 1, ());
-  TEST_EQUAL(nodeAttrs.m_parentInfo[0].m_id, "Countries", ());
+  TEST_EQUAL(nodeAttrs.m_parentInfo[0].m_id, COUNTRIES_ROOT, ());
   TEST_EQUAL(nodeAttrs.m_downloadingProgress.m_bytesDownloaded, 0, ());
   TEST_EQUAL(nodeAttrs.m_downloadingProgress.m_bytesTotal, 0, ());
   TEST_EQUAL(nodeAttrs.m_localMwmCounter, 0, ());
@@ -1340,7 +1341,7 @@ UNIT_TEST(StorageTest_GetQueuedChildrenSmokeTest)
   InitStorage(storage, runner);
 
   CountriesVec queuedChildren;
-  storage.GetQueuedChildren("Countries", queuedChildren);
+  storage.GetQueuedChildren(COUNTRIES_ROOT, queuedChildren);
   TEST(queuedChildren.empty(), ());
 
   storage.GetQueuedChildren("Abkhazia", queuedChildren);
@@ -1349,7 +1350,7 @@ UNIT_TEST(StorageTest_GetQueuedChildrenSmokeTest)
   storage.GetQueuedChildren("Country1", queuedChildren);
   TEST(queuedChildren.empty(), ());
 }
-  
+
 UNIT_TEST(StorageTest_GetGroupNodePathToRootTest)
 {
   Storage storage;
@@ -1358,23 +1359,23 @@ UNIT_TEST(StorageTest_GetGroupNodePathToRootTest)
 
   storage.GetGroupNodePathToRoot("France_Auvergne_Allier", path);
   TEST(path.empty(), ());
-  
+
   storage.GetGroupNodePathToRoot("France_Auvergne", path);
   TEST_EQUAL(path.size(), 2, (path));
   TEST_EQUAL(path[0], "France", ());
-  TEST_EQUAL(path[1], "Countries", ());
-  
+  TEST_EQUAL(path[1], COUNTRIES_ROOT, ());
+
   storage.GetGroupNodePathToRoot("France", path);
   TEST_EQUAL(path.size(), 1, (path));
-  TEST_EQUAL(path[0], "Countries", ());
-  
+  TEST_EQUAL(path[0], COUNTRIES_ROOT, ());
+
   storage.GetGroupNodePathToRoot("US_Florida_Miami", path);
   TEST(path.empty(), ());
 
   storage.GetGroupNodePathToRoot("Florida", path);
   TEST_EQUAL(path.size(), 2, (path));
   TEST_EQUAL(path[0], "United States of America", ());
-  TEST_EQUAL(path[1], "Countries", ());
+  TEST_EQUAL(path[1], COUNTRIES_ROOT, ());
 
   storage.GetGroupNodePathToRoot("Country1", path);
   TEST(path.empty(), ());