[storage] Storing the CountryId of the latest request explicitly.

It was stored as the m_frozen field in the QueuedCountry before.
Now we store it directly in Storage.

Another solution would be to send a query to DiffManager but
due to its asynchronicity we observed the following:
- A cancel request arrives from the user. It is sent to the diff manager.
- The download queue is updated. The country is now in the "not downloaded"
  state because we are not sure which state it is in exactly and cannot
  afford to wait for the diff manager on the UI thread.
- Diff manager processes the request. The download queue is updated again,
  the country is now in the "diff downloaded but not applied" state.

storage/diff_scheme/diff_manager.hpp

@@ -41,7 +41,7 @@ public:
   };
 
   using OnDiffApplicationFinished =
-      std::function<void(generator::mwm_diff::DiffApplicationResult result)>;
+      std::function<void(generator::mwm_diff::DiffApplicationResult)>;
 
   // If the diff is available, sets |size| to its size and returns true.
   // Otherwise, returns false.

storage/queued_country.hpp

@@ -21,9 +21,6 @@ public:
   void ResetToDefaultOptions();
   bool SwitchToNextFile();
 
-  void SetFrozen(bool isFrozen) { m_isFrozen = isFrozen; }
-  bool IsFrozen() const { return m_isFrozen; }
-
   inline CountryId const & GetCountryId() const { return m_countryId; }
   inline MapOptions GetInitOptions() const { return m_init; }
   inline MapOptions GetCurrentFileOptions() const { return m_current; }

storage/storage.cpp

@@ -951,8 +951,6 @@ void Storage::RegisterDownloadedFiles(CountryId const & countryId, MapOptions op
 
   if (options == MapOptions::Diff)
   {
-    m_queue.begin()->SetFrozen(true);
-    NotifyStatusChangedForHierarchy(countryId);
     ApplyDiff(countryId, fn);
     return;
   }
@@ -1171,7 +1169,7 @@ bool Storage::IsDiffApplyingInProgressToCountry(CountryId const & countryId) con
   if (!IsCountryFirstInQueue(countryId))
     return false;
 
-  return m_queue.front().IsFrozen();
+  return m_queue.front().GetCountryId() == m_latestDiffRequest;
 }
 
 void Storage::SetLocale(string const & locale) { m_countryNameGetter.SetLocale(locale); }
@@ -1288,7 +1286,7 @@ bool Storage::DeleteCountryFilesFromDownloader(CountryId const & countryId)
   if (!queuedCountry)
     return false;
 
-  if (queuedCountry->IsFrozen())
+  if (m_latestDiffRequest && m_latestDiffRequest == countryId)
     m_diffsCancellable.Cancel();
 
   MapOptions const opt = queuedCountry->GetInitOptions();
@@ -1558,6 +1556,8 @@ void Storage::LoadDiffScheme()
 void Storage::ApplyDiff(CountryId const & countryId, function<void(bool isSuccess)> const & fn)
 {
   m_diffsCancellable.Reset();
+  m_latestDiffRequest = countryId;
+  NotifyStatusChangedForHierarchy(countryId);
 
   diffs::Manager::ApplyDiffParams params;
   params.m_diffFile =
@@ -1569,6 +1569,7 @@ void Storage::ApplyDiff(CountryId const & countryId, function<void(bool isSucces
   {
     ASSERT(false, ("Invalid attempt to get version of diff with country id:", countryId));
     fn(false);
+    m_latestDiffRequest = {};
     return;
   }
 
@@ -1588,6 +1589,7 @@ void Storage::ApplyDiff(CountryId const & countryId, function<void(bool isSucces
         }
 
         GetPlatform().RunTask(Platform::Thread::Gui, [this, fn, diffFile, countryId, result] {
+          m_latestDiffRequest = {};
           switch (result)
           {
           case DiffApplicationResult::Ok:

storage/storage.hpp

@@ -205,6 +205,8 @@ private:
   // calls to the diff manager's ApplyDiff are coordinated from the storage thread.
   base::Cancellable m_diffsCancellable;
 
+  boost::optional<TCountryId> m_latestDiffRequest;
+
   DownloadingPolicy m_defaultDownloadingPolicy;
   DownloadingPolicy * m_downloadingPolicy = &m_defaultDownloadingPolicy;