1 files changed, 49 insertions, 69 deletions

diff --git a/src/components/application_manager/src/application_state.cc b/src/components/application_manager/src/application_state.cc
index 6b440fad89..2fb583ab3e 100644
--- a/src/components/application_manager/src/application_state.cc
+++ b/src/components/application_manager/src/application_state.cc
@@ -173,10 +173,14 @@ void ApplicationState::AddHMIState(const WindowID window_id,
   if (hmi_states.end() != it) {
     SDL_LOG_WARN("Hmi state with ID "
                  << state->state_id() << "has been already applied for window "
-                 << window_id << " of this application. Ignoring");
-    return;
+                 << window_id << " of this application. Overwriting");
+    EraseHMIState(hmi_states, it);
   }
 
+  if (!hmi_states.empty()) {
+    HmiStatePtr back_state = hmi_states.back();
+    state->set_parent(back_state);
+  }
   hmi_states.push_back(state);
 }
 
@@ -185,6 +189,8 @@ void ApplicationState::RemoveHMIState(const WindowID window_id,
   SDL_LOG_AUTO_TRACE();
   sync_primitives::AutoLock auto_lock(hmi_states_map_lock_);
   HmiStates& hmi_states = hmi_states_map_[window_id];
+  // unable to remove regular state
+  DCHECK_OR_RETURN_VOID(state_id != HmiState::StateID::STATE_ID_REGULAR);
   HmiStates::iterator it = std::find_if(
       hmi_states.begin(), hmi_states.end(), StateIDComparator(state_id));
   if (hmi_states.end() == it) {
@@ -193,17 +199,24 @@ void ApplicationState::RemoveHMIState(const WindowID window_id,
     return;
   }
 
-  // unable to remove regular state
-  DCHECK_OR_RETURN_VOID(hmi_states.begin() != it);
-  HmiStates::iterator next = it;
-  HmiStates::iterator prev = it;
-  next++;
-  prev--;
-
-  if (next != hmi_states.end()) {
-    HmiStatePtr next_state = *next;
-    HmiStatePtr prev_state = *prev;
-    next_state->set_parent(prev_state);
+  EraseHMIState(hmi_states, it);
+}
+
+void ApplicationState::EraseHMIState(HmiStates& hmi_states,
+                                     HmiStates::iterator it) {
+  if (hmi_states.begin() == it) {
+    (*it)->set_parent(nullptr);
+  } else {
+    HmiStates::iterator next = it;
+    HmiStates::iterator prev = it;
+    next++;
+    prev--;
+
+    if (hmi_states.end() != next) {
+      HmiStatePtr next_state = *next;
+      HmiStatePtr prev_state = *prev;
+      next_state->set_parent(prev_state);
+    }
   }
 
   hmi_states.erase(it);
@@ -223,21 +236,11 @@ void ApplicationState::RemoveWindowHMIStates(const WindowID window_id) {
 
 void ApplicationState::RemovePostponedState(const WindowID window_id) {
   SDL_LOG_AUTO_TRACE();
-  sync_primitives::AutoLock auto_lock(hmi_states_map_lock_);
-  HmiStates& hmi_states = hmi_states_map_[window_id];
-  DCHECK_OR_RETURN_VOID(!hmi_states.empty());
-
-  StateIDComparator finder(HmiState::StateID::STATE_ID_POSTPONED);
-
-  HmiStates::iterator postponed_state =
-      std::find_if(hmi_states.begin(), hmi_states.end(), finder);
-
-  if (hmi_states.end() == postponed_state) {
+  sync_primitives::AutoLock auto_lock(postponed_states_map_lock_);
+  size_t deleted_elements = postponed_states_map_.erase(window_id);
+  if (0 == deleted_elements) {
     SDL_LOG_ERROR("No postponed state is set for window " << window_id);
-    return;
   }
-
-  hmi_states.erase(postponed_state);
 }
 
 void ApplicationState::SetRegularState(const WindowID window_id,
@@ -250,27 +253,21 @@ void ApplicationState::SetRegularState(const WindowID window_id,
   HmiStates& hmi_states = hmi_states_map_[window_id];
   DCHECK_OR_RETURN_VOID(!hmi_states.empty());
 
-  HmiStatePtr front_state = hmi_states.front();
-  HmiState::StateID front_state_id = front_state->state_id();
-  if (HmiState::StateID::STATE_ID_POSTPONED == front_state_id) {
-    // Drop postponed state
-    hmi_states.erase(hmi_states.begin());
-  }
-
   // Drop regular state
-  hmi_states.erase(hmi_states.begin());
+  HmiStates::iterator it =
+      std::find_if(hmi_states.begin(),
+                   hmi_states.end(),
+                   StateIDComparator(HmiState::StateID::STATE_ID_REGULAR));
+  DCHECK_OR_RETURN_VOID(hmi_states.end() != it);
+  EraseHMIState(hmi_states, it);
 
   if (!hmi_states.empty()) {
-    HmiStatePtr front_state = hmi_states.front();
-    front_state->set_parent(state);
+    HmiStatePtr back_state = hmi_states.back();
+    state->set_parent(back_state);
   }
 
   // Insert new regular state
-  hmi_states.insert(hmi_states.begin(), state);
-  if (HmiState::StateID::STATE_ID_POSTPONED == front_state_id) {
-    // Restore postponed state if it was before
-    hmi_states.insert(hmi_states.begin(), front_state);
-  }
+  hmi_states.push_back(state);
 }
 
 void ApplicationState::SetPostponedState(const WindowID window_id,
@@ -280,15 +277,8 @@ void ApplicationState::SetPostponedState(const WindowID window_id,
   DCHECK_OR_RETURN_VOID(state->state_id() ==
                         HmiState::StateID::STATE_ID_POSTPONED);
 
-  sync_primitives::AutoLock auto_lock(hmi_states_map_lock_);
-  HmiStates& hmi_states = hmi_states_map_[window_id];
-  DCHECK_OR_RETURN_VOID(!hmi_states.empty());
-  HmiStatePtr front_state = hmi_states.front();
-  if (front_state->state_id() == HmiState::StateID::STATE_ID_POSTPONED) {
-    hmi_states.erase(hmi_states.begin());
-  }
-
-  hmi_states.insert(hmi_states.begin(), state);
+  sync_primitives::AutoLock auto_lock(postponed_states_map_lock_);
+  postponed_states_map_[window_id] = state;
 }
 
 HmiStatePtr ApplicationState::CurrentHmiState(const WindowID window_id) const {
@@ -300,9 +290,6 @@ HmiStatePtr ApplicationState::CurrentHmiState(const WindowID window_id) const {
   DCHECK_OR_RETURN(!hmi_states.empty(), HmiStatePtr());
 
   HmiStatePtr back_state = hmi_states.back();
-  DCHECK_OR_RETURN(
-      back_state->state_id() != HmiState::StateID::STATE_ID_POSTPONED,
-      HmiStatePtr());
 
   return back_state;
 }
@@ -314,28 +301,21 @@ HmiStatePtr ApplicationState::RegularHmiState(const WindowID window_id) const {
 
   const HmiStates& hmi_states = it_states->second;
   DCHECK_OR_RETURN(!hmi_states.empty(), HmiStatePtr());
+  auto it =
+      std::find_if(hmi_states.begin(),
+                   hmi_states.end(),
+                   StateIDComparator(HmiState::StateID::STATE_ID_REGULAR));
+  DCHECK_OR_RETURN(hmi_states.end() != it, HmiStatePtr());
 
-  HmiStates::const_iterator front_itr = hmi_states.begin();
-  if ((*front_itr)->state_id() == HmiState::StateID::STATE_ID_POSTPONED) {
-    ++front_itr;
-  }
-
-  return *front_itr;
+  return *it;
 }
 
 HmiStatePtr ApplicationState::PostponedHmiState(
     const WindowID window_id) const {
-  sync_primitives::AutoLock auto_lock(hmi_states_map_lock_);
-  auto it_states = hmi_states_map_.find(window_id);
-  DCHECK_OR_RETURN(it_states != hmi_states_map_.end(), HmiStatePtr());
-
-  const HmiStates& hmi_states = it_states->second;
-  DCHECK_OR_RETURN(!hmi_states.empty(), HmiStatePtr());
+  sync_primitives::AutoLock auto_lock(postponed_states_map_lock_);
 
-  HmiStatePtr front_state = hmi_states.front();
-  return front_state->state_id() == HmiState::StateID::STATE_ID_POSTPONED
-             ? front_state
-             : HmiStatePtr();
+  auto it = postponed_states_map_.find(window_id);
+  return it != postponed_states_map_.end() ? it->second : HmiStatePtr();
 }
 
 }  // namespace application_manager