fix. Correct release of resources on GL shoutdown

map/coverage_generator.cpp

@@ -42,14 +42,15 @@ CoverageGenerator::CoverageGenerator(TileRenderer * tileRenderer,
 CoverageGenerator::~CoverageGenerator()
 {
   LOG(LINFO, ("cancelling coverage thread"));
-  m_queue.Cancel();
   ClearCoverage();
 }
 
 void CoverageGenerator::Shutdown()
 {
+  LOG(LINFO, ("shutdown resources"));
   m_stateInfo.SetSequenceID(numeric_limits<int>::max());
-  m_queue.Join();
+  m_queue.CancelCommands();
+  m_queue.Cancel();
 }
 
 void CoverageGenerator::InitializeThreadGL(shared_ptr<graphics::RenderContext> context,

map/coverage_generator.hpp

@@ -52,20 +52,9 @@ public:
 
   void Shutdown();
 
-  //@{ Called only on android, with Single thread policy
-  void InitializeThreadGL(shared_ptr<graphics::RenderContext> context,
-                          shared_ptr<graphics::ResourceManager> resourceManager,
-                          graphics::PacketsQueue * glQueue);
-  void FinalizeThreadGL(shared_ptr<graphics::RenderContext> context,
-                        shared_ptr<graphics::ResourceManager> resourceManager);
-  //@}
-
   //@{ Add task to run on CoverageGenerator thread
   void InvalidateTiles(m2::AnyRectD const & rect, int startScale);
   void CoverScreen(ScreenBase const & screen, bool doForce);
-  void MergeTile(Tiler::RectInfo const & rectInfo,
-                        int sequenceID);
-  void CheckEmptyModel(int sequenceID);
   //}@
 
   //@{ Benchmark support
@@ -93,6 +82,19 @@ public:
 
   int GetDrawScale() const;
 
+private:
+  //@{ Called only on android, with Single thread policy
+  void InitializeThreadGL(shared_ptr<graphics::RenderContext> context,
+                          shared_ptr<graphics::ResourceManager> resourceManager,
+                          graphics::PacketsQueue * glQueue);
+  void FinalizeThreadGL(shared_ptr<graphics::RenderContext> context,
+                        shared_ptr<graphics::ResourceManager> resourceManager);
+  //@}
+
+  void MergeTile(Tiler::RectInfo const & rectInfo,
+                        int sequenceID);
+  void CheckEmptyModel(int sequenceID);
+
 private:
   void CoverScreenImpl(core::CommandsQueue::Environment const & env,
                        ScreenBase const & screen,

map/tile_renderer.cpp

@@ -56,7 +56,6 @@ TileRenderer::TileRenderer(
   , m_renderFn(renderFn)
   , m_bgColor(bgColor)
   , m_sequenceID(0)
-  , m_isExiting(false)
   , m_isPaused(false)
 {
   m_resourceManager = rm;
@@ -106,8 +105,13 @@ TileRenderer::TileRenderer(
 
 TileRenderer::~TileRenderer()
 {
-  m_isExiting = true;
+}
 
+void TileRenderer::Shutdown()
+{
+  LOG(LINFO, ("shutdown resources"));
+  SetSequenceID(numeric_limits<int>::max());
+  m_queue.CancelCommands();
   m_queue.Cancel();
 
   for (size_t i = 0; i < m_threadData.size(); ++i)
@@ -261,17 +265,13 @@ void TileRenderer::DrawTile(core::CommandsQueue::Environment const & env,
   }
   else
   {
-    if (!m_isExiting)
-    {
-      if (glQueue)
-        glQueue->cancelCommands();
-    }
+    if (glQueue)
+      glQueue->cancelCommands();
   }
 
   if (env.isCancelled())
   {
-    if (!m_isExiting)
-      texturePool->Free(tileTarget);
+    texturePool->Free(tileTarget);
   }
   else
   {
@@ -335,11 +335,6 @@ void TileRenderer::CacheActiveTile(Tiler::RectInfo const & rectInfo)
   }
 }
 
-void TileRenderer::WaitForEmptyAndFinished()
-{
-  m_queue.Join();
-}
-
 bool TileRenderer::HasTile(Tiler::RectInfo const & rectInfo)
 {
   TileStructuresLockGuard guard(m_tileCache, m_tileSet);

map/tile_renderer.hpp

@@ -60,7 +60,6 @@ protected:
   RenderPolicy::TRenderFn m_renderFn;
   graphics::Color m_bgColor;
   int m_sequenceID;
-  bool m_isExiting;
 
   bool m_isPaused;
 
@@ -91,6 +90,7 @@ public:
                graphics::PacketsQueue ** packetsQueue);
   /// destructor.
   virtual ~TileRenderer();
+  void Shutdown();
   /// add command to the commands queue.
   void AddCommand(Tiler::RectInfo const & rectInfo,
                   int sequenceID,
@@ -99,8 +99,6 @@ public:
   TileCache & GetTileCache();
   /// Move active tile to cache if tile alrady rendered
   void CacheActiveTile(Tiler::RectInfo const & rectInfo);
-  /// wait on a condition variable for an empty queue.
-  void WaitForEmptyAndFinished();
 
   void SetSequenceID(int sequenceID);
 

map/tiling_render_policy_mt.cpp

@@ -149,13 +149,10 @@ TilingRenderPolicyMT::~TilingRenderPolicyMT()
   LOG(LINFO, ("cancelling ResourceManager"));
   m_resourceManager->cancel();
 
+  m_CoverageGenerator->Shutdown();
+  m_TileRenderer->Shutdown();
+
   m_CoverageGenerator.reset();
-
-  m_TileRenderer->ClearCommands();
-  m_TileRenderer->SetSequenceID(numeric_limits<int>::max());
-  m_TileRenderer->CancelCommands();
-  m_TileRenderer->WaitForEmptyAndFinished();
-
   m_TileRenderer.reset();
 }
 

map/tiling_render_policy_st.cpp

@@ -158,30 +158,23 @@ TilingRenderPolicyST::~TilingRenderPolicyST()
   LOG(LINFO, ("deleting TilingRenderPolicyST"));
 
   m_QueuedRenderer->PrepareQueueCancellation(cpuCores);
-
   /// now we should process all commands to collect them into queues
   m_CoverageGenerator->Shutdown();
-
   m_QueuedRenderer->CancelQueuedCommands(cpuCores);
 
-  LOG(LINFO, ("reseting coverageGenerator"));
-  m_CoverageGenerator.reset();
-
   /// firstly stop all rendering commands in progress and collect all commands into queues
 
   for (unsigned i = 0; i < cpuCores; ++i)
     m_QueuedRenderer->PrepareQueueCancellation(i);
 
-  m_TileRenderer->ClearCommands();
-  m_TileRenderer->SetSequenceID(numeric_limits<int>::max());
-  m_TileRenderer->CancelCommands();
-  m_TileRenderer->WaitForEmptyAndFinished();
-
+  m_TileRenderer->Shutdown();
   /// now we should cancel all collected commands
 
   for (unsigned i = 0; i < cpuCores; ++i)
     m_QueuedRenderer->CancelQueuedCommands(i);
 
+  LOG(LINFO, ("reseting coverageGenerator"));
+  m_CoverageGenerator.reset();
   LOG(LINFO, ("reseting tileRenderer"));
   m_TileRenderer.reset();
   LOG(LINFO, ("done reseting tileRenderer"));