Soft processing of android context destruction.

15 files changed, 236 insertions, 58 deletions

diff --git a/drape_frontend/backend_renderer.cpp b/drape_frontend/backend_renderer.cpp
index d7a7af41f5..b959923619 100644
--- a/drape_frontend/backend_renderer.cpp
+++ b/drape_frontend/backend_renderer.cpp
@@ -319,16 +319,33 @@ void BackendRenderer::ReleaseResources()
   m_contextFactory->getResourcesUploadContext()->doneCurrent();
 }
 
-BackendRenderer::Routine::Routine(BackendRenderer & renderer) : m_renderer(renderer) {}
-
-void BackendRenderer::Routine::Do()
+void BackendRenderer::OnContextCreate()
 {
-  m_renderer.m_contextFactory->waitForInitialization();
+  LOG(LWARNING, ("On context create."));
+  m_contextFactory->waitForInitialization();
+  m_contextFactory->getResourcesUploadContext()->makeCurrent();
 
-  m_renderer.m_contextFactory->getResourcesUploadContext()->makeCurrent();
   GLFunctions::Init();
 
-  m_renderer.InitGLDependentResource();
+  InitGLDependentResource();
+}
+
+void BackendRenderer::OnContextDestroy()
+{
+  LOG(LWARNING, ("On context destroy."));
+  m_readManager->InvalidateAll();
+  m_batchersPool.reset();
+  m_texMng->Release();
+
+  m_contextFactory->getResourcesUploadContext()->doneCurrent();
+}
+
+BackendRenderer::Routine::Routine(BackendRenderer & renderer) : m_renderer(renderer) {}
+
+void BackendRenderer::Routine::Do()
+{
+  LOG(LWARNING, ("Start routine."));
+  m_renderer.OnContextCreate();
 
   while (!IsCancelled())
   {
diff --git a/drape_frontend/backend_renderer.hpp b/drape_frontend/backend_renderer.hpp
index 8222f674a7..ca34b14e4a 100644
--- a/drape_frontend/backend_renderer.hpp
+++ b/drape_frontend/backend_renderer.hpp
@@ -58,6 +58,9 @@ public:
 protected:
   unique_ptr<threads::IRoutine> CreateRoutine() override;
 
+  void OnContextCreate() override;
+  void OnContextDestroy() override;
+
 private:
   void RecacheGui(gui::TWidgetsInitInfo const & initInfo, bool needResetOldGui);
   void RecacheChoosePositionMark();
diff --git a/drape_frontend/base_renderer.cpp b/drape_frontend/base_renderer.cpp
index 8cc083b2ca..725c43b7a5 100644
--- a/drape_frontend/base_renderer.cpp
+++ b/drape_frontend/base_renderer.cpp
@@ -39,23 +39,18 @@ void BaseRenderer::StopThread()
   m_selfThread.Join();
 }
 
-void BaseRenderer::SetRenderingEnabled(bool const isEnabled)
+void BaseRenderer::SetRenderingEnabled(ref_ptr<dp::OGLContextFactory> contextFactory)
 {
-  // here we have to wait for completion of internal SetRenderingEnabled
-  mutex completionMutex;
-  condition_variable completionCondition;
-  bool notified = false;
-  auto completionHandler = [&]()
-  {
-    lock_guard<mutex> lock(completionMutex);
-    notified = true;
-    completionCondition.notify_one();
-  };
-
-  SetRenderingEnabled(isEnabled, completionHandler);
+  if (m_wasContextReset)
+    m_contextFactory = contextFactory;
+  SetRenderingEnabled(true);
+}
 
-  unique_lock<mutex> lock(completionMutex);
-  completionCondition.wait(lock, [&notified] { return notified; });
+void BaseRenderer::SetRenderingDisabled(bool const destroyContext)
+{
+  if (destroyContext)
+    m_wasContextReset = true;
+  SetRenderingEnabled(false);
 }
 
 bool BaseRenderer::IsRenderingEnabled() const
@@ -63,17 +58,22 @@ bool BaseRenderer::IsRenderingEnabled() const
   return m_isEnabled;
 }
 
-void BaseRenderer::SetRenderingEnabled(bool const isEnabled, TCompletionHandler completionHandler)
+void BaseRenderer::SetRenderingEnabled(bool const isEnabled)
 {
   if (isEnabled == m_isEnabled)
-  {
-    if (completionHandler != nullptr)
-      completionHandler();
-
     return;
-  }
 
-  m_renderingEnablingCompletionHandler = move(completionHandler);
+  // here we have to wait for completion of internal SetRenderingEnabled
+  mutex completionMutex;
+  condition_variable completionCondition;
+  bool notified = false;
+  m_renderingEnablingCompletionHandler = [&]()
+  {
+    lock_guard<mutex> lock(completionMutex);
+    notified = true;
+    completionCondition.notify_one();
+  };
+
   if (isEnabled)
   {
     // wake up rendering thread
@@ -87,19 +87,30 @@ void BaseRenderer::SetRenderingEnabled(bool const isEnabled, TCompletionHandler
     // if renderer thread is waiting for message let it go
     CancelMessageWaiting();
   }
+
+  unique_lock<mutex> lock(completionMutex);
+  completionCondition.wait(lock, [&notified] { return notified; });
 }
 
 void BaseRenderer::CheckRenderingEnabled()
 {
   if (!m_isEnabled)
   {
-    bool const isDrawContext = m_threadName == ThreadsCommutator::RenderThread;
-    dp::OGLContext * context = isDrawContext ? m_contextFactory->getDrawContext() :
-                                               m_contextFactory->getResourcesUploadContext();
-
-    context->setRenderingEnabled(false);
-
-    // nofity initiator-thread about rendering disabling
+    dp::OGLContext * context = nullptr;
+
+    if (m_wasContextReset)
+    {
+      OnContextDestroy();
+    }
+    else
+    {
+      bool const isDrawContext = m_threadName == ThreadsCommutator::RenderThread;
+      context = isDrawContext ? m_contextFactory->getDrawContext() :
+                                m_contextFactory->getResourcesUploadContext();
+      context->setRenderingEnabled(false);
+    }
+
+    // notify initiator-thread about rendering disabling
     Notify();
 
     // wait for signal
@@ -110,9 +121,17 @@ void BaseRenderer::CheckRenderingEnabled()
     m_wasNotified = false;
     m_isEnabled = true;
 
-    context->setRenderingEnabled(true);
-
-    // nofity initiator-thread about rendering enabling
+    if (m_wasContextReset)
+    {
+      m_wasContextReset = false;
+      OnContextCreate();
+    }
+    else
+    {
+      context->setRenderingEnabled(true);
+    }
+
+    // notify initiator-thread about rendering enabling
     // m_renderingEnablingCompletionHandler will be setup before awakening of this thread
     Notify();
   }
diff --git a/drape_frontend/base_renderer.hpp b/drape_frontend/base_renderer.hpp
index 14d4da18b4..d0e446d7c3 100644
--- a/drape_frontend/base_renderer.hpp
+++ b/drape_frontend/base_renderer.hpp
@@ -40,7 +40,9 @@ public:
 
   bool CanReceiveMessages();
 
-  void SetRenderingEnabled(bool const isEnabled);
+  void SetRenderingEnabled(ref_ptr<dp::OGLContextFactory> contextFactory);
+  void SetRenderingDisabled(bool const destroyContext);
+
   bool IsRenderingEnabled() const;
 
 protected:
@@ -55,6 +57,9 @@ protected:
 
   virtual unique_ptr<threads::IRoutine> CreateRoutine() = 0;
 
+  virtual void OnContextCreate() = 0;
+  virtual void OnContextDestroy() = 0;
+
 private:
   using TCompletionHandler = function<void()>;
 
@@ -67,7 +72,9 @@ private:
   TCompletionHandler m_renderingEnablingCompletionHandler;
   bool m_wasNotified;
 
-  void SetRenderingEnabled(bool const isEnabled, TCompletionHandler completionHandler);
+  atomic<bool> m_wasContextReset;
+
+  void SetRenderingEnabled(bool const isEnabled);
   void Notify();
   void WakeUp();
 };
diff --git a/drape_frontend/drape_engine.cpp b/drape_frontend/drape_engine.cpp
index 9b2698c9b8..5b2d4be1dc 100644
--- a/drape_frontend/drape_engine.cpp
+++ b/drape_frontend/drape_engine.cpp
@@ -92,6 +92,24 @@ DrapeEngine::~DrapeEngine()
   m_textureManager->Release();
 }
 
+void DrapeEngine::Update(int w, int h)
+{
+  LOG(LWARNING, (w, h));
+
+  RecacheGui(false);
+
+  UpdateMapStyleMessage::Blocker blocker;
+  m_threadCommutator->PostMessage(ThreadsCommutator::RenderThread,
+                                  make_unique_dp<UpdateMapStyleMessage>(blocker),
+                                  MessagePriority::High);
+  blocker.Wait();
+
+  m_threadCommutator->PostMessage(ThreadsCommutator::ResourceUploadThread,
+                                  make_unique_dp<GuiLayerLayoutMessage>(m_widgetsLayout),
+                                  MessagePriority::Normal);
+  ResizeImpl(w, h);
+}
+
 void DrapeEngine::Resize(int w, int h)
 {
   if (m_viewport.GetHeight() != h || m_viewport.GetWidth() != w)
@@ -151,12 +169,20 @@ void DrapeEngine::UpdateUserMarksLayer(TileKey const & tileKey, UserMarksProvide
                                   MessagePriority::Normal);
 }
 
-void DrapeEngine::SetRenderingEnabled(bool const isEnabled)
+void DrapeEngine::SetRenderingEnabled(ref_ptr<dp::OGLContextFactory> contextFactory)
+{
+  m_backend->SetRenderingEnabled(contextFactory);
+  m_frontend->SetRenderingEnabled(contextFactory);
+
+  LOG(LDEBUG, ("Rendering enabled"));
+}
+
+void DrapeEngine::SetRenderingDisabled(bool const destroyContext)
 {
-  m_frontend->SetRenderingEnabled(isEnabled);
-  m_backend->SetRenderingEnabled(isEnabled);
+  m_frontend->SetRenderingDisabled(destroyContext);
+  m_backend->SetRenderingDisabled(destroyContext);
 
-  LOG(LDEBUG, (isEnabled ? "Rendering enabled" : "Rendering disabled"));
+  LOG(LDEBUG, ("Rendering disabled"));
 }
 
 void DrapeEngine::InvalidateRect(m2::RectD const & rect)
diff --git a/drape_frontend/drape_engine.hpp b/drape_frontend/drape_engine.hpp
index 12c86481cc..2b64b79eaf 100644
--- a/drape_frontend/drape_engine.hpp
+++ b/drape_frontend/drape_engine.hpp
@@ -84,6 +84,8 @@ public:
   DrapeEngine(Params && params);
   ~DrapeEngine();
 
+  void Update(int w, int h);
+
   void Resize(int w, int h);
   void Invalidate();
 
@@ -102,7 +104,8 @@ public:
   void ChangeVisibilityUserMarksLayer(TileKey const & tileKey, bool isVisible);
   void UpdateUserMarksLayer(TileKey const & tileKey, UserMarksProvider * provider);
 
-  void SetRenderingEnabled(bool const isEnabled);
+  void SetRenderingEnabled(ref_ptr<dp::OGLContextFactory> contextFactory);
+  void SetRenderingDisabled(bool const destroyContext);
   void InvalidateRect(m2::RectD const & rect);
   void UpdateMapStyle();
 
diff --git a/drape_frontend/frontend_renderer.cpp b/drape_frontend/frontend_renderer.cpp
index 38d71b5e2e..dbf559fbb0 100755
--- a/drape_frontend/frontend_renderer.cpp
+++ b/drape_frontend/frontend_renderer.cpp
@@ -129,6 +129,7 @@ FrontendRenderer::FrontendRenderer(Params const & params)
   , m_userPositionChangedFn(params.m_positionChangedFn)
   , m_requestedTiles(params.m_requestedTiles)
   , m_maxGeneration(0)
+  , m_needRestoreSize(false)
 {
 #ifdef DRAW_INFO
   m_tpf = 0.0;
@@ -819,8 +820,13 @@ void FrontendRenderer::OnResize(ScreenBase const & screen)
   {
     m_myPositionController->OnNewViewportRect();
     m_viewport.SetViewport(0, 0, viewportRect.SizeX(), viewportRect.SizeY());
+  }
+
+  if (viewportChanged || m_needRestoreSize)
+  {
     m_contextFactory->getDrawContext()->resize(viewportRect.SizeX(), viewportRect.SizeY());
     m_framebuffer->SetSize(viewportRect.SizeX(), viewportRect.SizeY());
+    m_needRestoreSize = false;
   }
 
   RefreshProjection(screen);
@@ -1451,24 +1457,49 @@ TTilesCollection FrontendRenderer::ResolveTileKeys(ScreenBase const & screen)
   return tiles;
 }
 
-FrontendRenderer::Routine::Routine(FrontendRenderer & renderer) : m_renderer(renderer) {}
+void FrontendRenderer::OnContextDestroy()
+{
+  LOG(LWARNING, ("On context destroy."));
 
-void FrontendRenderer::Routine::Do()
+  // Clear all graphics.
+  for (RenderLayer & layer : m_layers)
+  {
+    layer.m_renderGroups.clear();
+    layer.m_isDirty = false;
+  }
+
+  m_userMarkRenderGroups.clear();
+  m_guiRenderer.reset();
+  m_selectionShape.release();
+  m_framebuffer.reset();
+  m_transparentLayer.reset();
+
+  m_myPositionController->ResetRenderShape();
+  m_routeRenderer->ClearGLDependentResources();
+  m_gpsTrackRenderer->ClearRenderData();
+
+#ifdef RENDER_DEBUG_RECTS
+  dp::DebugRectRenderer::Instance().Destroy();
+#endif
+
+  m_gpuProgramManager.reset();
+  m_contextFactory->getDrawContext()->doneCurrent();
+
+  m_needRestoreSize = true;
+}
+
+void FrontendRenderer::OnContextCreate()
 {
-  m_renderer.m_contextFactory->waitForInitialization();
+  LOG(LWARNING, ("On context create."));
 
-  gui::DrapeGui::Instance().ConnectOnCompassTappedHandler(bind(&FrontendRenderer::OnCompassTapped, &m_renderer));
-  m_renderer.m_myPositionController->SetListener(ref_ptr<MyPositionController::Listener>(&m_renderer));
-  m_renderer.m_userEventStream.SetListener(ref_ptr<UserEventStream::Listener>(&m_renderer));
+  m_contextFactory->waitForInitialization();
 
-  dp::OGLContext * context = m_renderer.m_contextFactory->getDrawContext();
+  dp::OGLContext * context = m_contextFactory->getDrawContext();
   context->makeCurrent();
-  m_renderer.m_framebuffer->SetDefaultContext(context);
+
   GLFunctions::Init();
   GLFunctions::AttachCache(this_thread::get_id());
 
-  dp::SupportManager::Instance().Init();
-
   GLFunctions::glPixelStore(gl_const::GLUnpackAlignment, 1);
   GLFunctions::glEnable(gl_const::GLDepthTest);
 
@@ -1481,7 +1512,10 @@ void FrontendRenderer::Routine::Do()
   GLFunctions::glEnable(gl_const::GLCullFace);
   GLFunctions::glEnable(gl_const::GLScissorTest);
 
-  m_renderer.m_gpuProgramManager->Init();
+  dp::SupportManager::Instance().Init();
+
+  m_gpuProgramManager = make_unique_dp<dp::GpuProgramManager>();
+  m_gpuProgramManager->Init();
 
   dp::BlendingParams blendingParams;
   blendingParams.Apply();
@@ -1490,6 +1524,25 @@ void FrontendRenderer::Routine::Do()
   dp::DebugRectRenderer::Instance().Init(make_ref(m_renderer.m_gpuProgramManager));
 #endif
 
+  // resources recovering
+  m_framebuffer.reset(new Framebuffer());
+  m_framebuffer->SetDefaultContext(context);
+
+  m_transparentLayer.reset(new TransparentLayer());
+}
+
+FrontendRenderer::Routine::Routine(FrontendRenderer & renderer) : m_renderer(renderer) {}
+
+void FrontendRenderer::Routine::Do()
+{
+  LOG(LWARNING, ("Start routine"));
+
+  gui::DrapeGui::Instance().ConnectOnCompassTappedHandler(bind(&FrontendRenderer::OnCompassTapped, &m_renderer));
+  m_renderer.m_myPositionController->SetListener(ref_ptr<MyPositionController::Listener>(&m_renderer));
+  m_renderer.m_userEventStream.SetListener(ref_ptr<UserEventStream::Listener>(&m_renderer));
+
+  m_renderer.OnContextCreate();
+
   double const kMaxInactiveSeconds = 2.0;
 
   my::Timer timer;
@@ -1499,6 +1552,8 @@ void FrontendRenderer::Routine::Do()
   bool modelViewChanged = true;
   bool viewportChanged = true;
 
+  dp::OGLContext * context = m_renderer.m_contextFactory->getDrawContext();
+
   while (!IsCancelled())
   {
     ScreenBase modelView = m_renderer.ProcessEvents(modelViewChanged, viewportChanged);
diff --git a/drape_frontend/frontend_renderer.hpp b/drape_frontend/frontend_renderer.hpp
index 2bb43a25be..54267771ce 100755
--- a/drape_frontend/frontend_renderer.hpp
+++ b/drape_frontend/frontend_renderer.hpp
@@ -151,6 +151,8 @@ public:
 protected:
   void AcceptMessage(ref_ptr<Message> message) override;
   unique_ptr<threads::IRoutine> CreateRoutine() override;
+  void OnContextCreate() override;
+  void OnContextDestroy() override;
 
 private:
   void OnResize(ScreenBase const & screen);
@@ -325,6 +327,8 @@ private:
 
   drape_ptr<SelectObjectMessage> m_selectObjectMessage;
 
+  bool m_needRestoreSize;
+
 #ifdef DEBUG
   bool m_isTeardowned;
 #endif
diff --git a/drape_frontend/gps_track_renderer.cpp b/drape_frontend/gps_track_renderer.cpp
index d3c82e404e..b5137402be 100644
--- a/drape_frontend/gps_track_renderer.cpp
+++ b/drape_frontend/gps_track_renderer.cpp
@@ -90,6 +90,12 @@ void GpsTrackRenderer::AddRenderData(ref_ptr<dp::GpuProgramManager> mng,
   m_waitForRenderData = false;
 }
 
+void GpsTrackRenderer::ClearRenderData()
+{
+  m_renderData.clear();
+  m_waitForRenderData = false;
+}
+
 void GpsTrackRenderer::UpdatePoints(vector<GpsTrackPoint> const & toAdd, vector<uint32_t> const & toRemove)
 {
   bool wasChanged = false;
diff --git a/drape_frontend/gps_track_renderer.hpp b/drape_frontend/gps_track_renderer.hpp
index 0ddd6063d3..cb40cb34e8 100644
--- a/drape_frontend/gps_track_renderer.hpp
+++ b/drape_frontend/gps_track_renderer.hpp
@@ -34,6 +34,7 @@ public:
 
   void Update();
   void Clear();
+  void ClearRenderData();
 
 private:
   float CalculateRadius(ScreenBase const & screen) const;
diff --git a/drape_frontend/my_position_controller.cpp b/drape_frontend/my_position_controller.cpp
index 3d868a8efd..e51f72c1ce 100644
--- a/drape_frontend/my_position_controller.cpp
+++ b/drape_frontend/my_position_controller.cpp
@@ -285,6 +285,11 @@ void MyPositionController::SetRenderShape(drape_ptr<MyPosition> && shape)
   m_shape = move(shape);
 }
 
+void MyPositionController::ResetRenderShape()
+{
+  m_shape.reset();
+}
+
 void MyPositionController::NextMode(ScreenBase const & screen)
 {
   string const kAlohalyticsClickEvent = "$onClick";
diff --git a/drape_frontend/my_position_controller.hpp b/drape_frontend/my_position_controller.hpp
index 00bd0be3bc..9d555fc880 100644
--- a/drape_frontend/my_position_controller.hpp
+++ b/drape_frontend/my_position_controller.hpp
@@ -69,6 +69,7 @@ public:
   void CorrectGlobalScalePoint(m2::PointD & pt) const;
 
   void SetRenderShape(drape_ptr<MyPosition> && shape);
+  void ResetRenderShape();
 
   void ActivateRouting(int zoomLevel, bool enableAutoZoom);
   void DeactivateRouting();
diff --git a/drape_frontend/route_renderer.cpp b/drape_frontend/route_renderer.cpp
index 4a7b115980..3f041b3ce7 100644
--- a/drape_frontend/route_renderer.cpp
+++ b/drape_frontend/route_renderer.cpp
@@ -229,7 +229,7 @@ void RouteRenderer::UpdateRoute(ScreenBase const & screen, TCacheRouteArrowsCall
 void RouteRenderer::RenderRoute(ScreenBase const & screen, ref_ptr<dp::GpuProgramManager> mng,
                                 dp::UniformValuesStorage const & commonUniforms)
 {
-  if (!m_routeData)
+  if (!m_routeData || m_invalidGLResources)
     return;
 
   // Render route.
@@ -284,6 +284,9 @@ void RouteRenderer::RenderRoute(ScreenBase const & screen, ref_ptr<dp::GpuProgra
 void RouteRenderer::RenderRouteSigns(ScreenBase const & screen, ref_ptr<dp::GpuProgramManager> mng,
                                      dp::UniformValuesStorage const & commonUniforms)
 {
+  if (m_invalidGLResources)
+    return;
+
   if (m_startRouteSign)
   {
     ASSERT(m_startRouteSign->m_isValid, ());
@@ -301,6 +304,9 @@ void RouteRenderer::RenderRouteSign(drape_ptr<RouteSignData> const & sign, Scree
                                     ref_ptr<dp::GpuProgramManager> mng,
                                     dp::UniformValuesStorage const & commonUniforms)
 {
+  if (m_invalidGLResources)
+    return;
+
   dp::GLState const & state = sign->m_sign.m_state;
 
   dp::UniformValuesStorage uniforms = commonUniforms;
@@ -322,6 +328,8 @@ void RouteRenderer::RenderRouteSign(drape_ptr<RouteSignData> const & sign, Scree
 
 void RouteRenderer::SetRouteData(drape_ptr<RouteData> && routeData, ref_ptr<dp::GpuProgramManager> mng)
 {
+  m_invalidGLResources = false;
+
   m_routeData = move(routeData);
   m_arrowBorders.clear();
 
@@ -331,6 +339,8 @@ void RouteRenderer::SetRouteData(drape_ptr<RouteData> && routeData, ref_ptr<dp::
 
 void RouteRenderer::SetRouteSign(drape_ptr<RouteSignData> && routeSignData, ref_ptr<dp::GpuProgramManager> mng)
 {
+  m_invalidGLResources = false;
+
   if (routeSignData->m_isStart)
   {
     if (!routeSignData->m_isValid)
@@ -373,6 +383,8 @@ drape_ptr<RouteData> const & RouteRenderer::GetRouteData() const
 void RouteRenderer::SetRouteArrows(drape_ptr<RouteArrowsData> && routeArrowsData,
                                    ref_ptr<dp::GpuProgramManager> mng)
 {
+  m_invalidGLResources = false;
+
   m_routeArrows = move(routeArrowsData);
   BuildBuckets(m_routeArrows->m_arrows, mng);
 }
@@ -389,6 +401,19 @@ void RouteRenderer::Clear(bool keepDistanceFromBegin)
     m_distanceFromBegin = 0.0;
 }
 
+void RouteRenderer::ClearGLDependentResources()
+{
+  m_invalidGLResources = true;
+
+  if (m_routeData != nullptr)
+    m_routeData->m_route.m_buckets.clear();
+  if (m_startRouteSign != nullptr)
+    m_startRouteSign->m_sign.m_buckets.clear();
+  if (m_finishRouteSign != nullptr)
+    m_finishRouteSign->m_sign.m_buckets.clear();
+  m_routeArrows.reset();
+}
+
 void RouteRenderer::UpdateDistanceFromBegin(double distanceFromBegin)
 {
   m_distanceFromBegin = distanceFromBegin;
diff --git a/drape_frontend/route_renderer.hpp b/drape_frontend/route_renderer.hpp
index a9f530704c..f98b9858f5 100644
--- a/drape_frontend/route_renderer.hpp
+++ b/drape_frontend/route_renderer.hpp
@@ -35,6 +35,7 @@ public:
   void SetRouteArrows(drape_ptr<RouteArrowsData> && routeArrowsData, ref_ptr<dp::GpuProgramManager> mng);
 
   void Clear(bool keepDistanceFromBegin = false);
+  void ClearGLDependentResources();
 
   void UpdateDistanceFromBegin(double distanceFromBegin);
 
@@ -54,6 +55,8 @@ private:
 
   float m_currentHalfWidth = 0.0f;
   float m_currentAlpha = 0.0f;
+
+  bool m_invalidGLResources = false;
 };
 
 } // namespace df
diff --git a/drape_frontend/user_event_stream.cpp b/drape_frontend/user_event_stream.cpp
index c51a63338f..e97e74a7e5 100644
--- a/drape_frontend/user_event_stream.cpp
+++ b/drape_frontend/user_event_stream.cpp
@@ -160,7 +160,9 @@ ScreenBase const & UserEventStream::ProcessEvents(bool & modelViewChanged, bool
 
   m2::RectD const prevPixelRect = GetCurrentScreen().PixelRect();
 
+  viewportChanged = false;
   m_modelViewChanged = !events.empty() || m_state == STATE_SCALE || m_state == STATE_DRAG;
+
   for (auto const & e : events)
   {
     bool breakAnim = false;
@@ -178,6 +180,7 @@ ScreenBase const & UserEventStream::ProcessEvents(bool & modelViewChanged, bool
       {
         ref_ptr<ResizeEvent> resizeEvent = make_ref(e);
         m_navigator.OnSize(resizeEvent->GetWidth(), resizeEvent->GetHeight());
+        viewportChanged = true;
         breakAnim = true;
         TouchCancel(m_touches);
         if (m_state == STATE_DOUBLE_TAP_HOLD)
@@ -258,7 +261,7 @@ ScreenBase const & UserEventStream::ProcessEvents(bool & modelViewChanged, bool
   modelViewChanged = m_modelViewChanged;
 
   double const kEps = 1e-5;
-  viewportChanged = !m2::IsEqualSize(prevPixelRect, GetCurrentScreen().PixelRect(), kEps, kEps);
+  viewportChanged |= !m2::IsEqualSize(prevPixelRect, GetCurrentScreen().PixelRect(), kEps, kEps);
   m_modelViewChanged = false;
 
   return m_navigator.Screen();