Core dump on ignition off when registering 20 apps (#3939)

* Add changes from luxoft PR

* Address review comments

* Apply suggestions from code review

Co-authored-by: Jacob Keeler <jacob.keeler@livioradio.com>

* Address review comments

* Use sync_primitives::RecursiveLock instead of sync_primitives::Lock for extensions_lock_

Co-authored-by: Jacob Keeler <jacob.keeler@livioradio.com>

21 files changed, 179 insertions, 70 deletions

diff --git a/src/components/application_manager/include/application_manager/application.h b/src/components/application_manager/include/application_manager/application.h
index e018c28c54..d37a211044 100644
--- a/src/components/application_manager/include/application_manager/application.h
+++ b/src/components/application_manager/include/application_manager/application.h
@@ -1181,7 +1181,8 @@ class Application : public virtual InitialApplicationData,
    * @brief Get list of available application extensions
    * @return application extensions
    */
-  virtual const std::list<AppExtensionPtr>& Extensions() const = 0;
+  virtual const DataAccessor<std::list<AppExtensionPtr> > Extensions()
+      const = 0;
 
   /**
    * @brief Get cloud app endpoint for websocket connection
diff --git a/src/components/application_manager/include/application_manager/application_impl.h b/src/components/application_manager/include/application_manager/application_impl.h
index 49f44acacb..1746893be3 100644
--- a/src/components/application_manager/include/application_manager/application_impl.h
+++ b/src/components/application_manager/include/application_manager/application_impl.h
@@ -555,7 +555,7 @@ class ApplicationImpl : public virtual Application,
    */
   bool RemoveExtension(AppExtensionUID uid) OVERRIDE;
 
-  const std::list<AppExtensionPtr>& Extensions() const OVERRIDE;
+  const DataAccessor<std::list<AppExtensionPtr> > Extensions() const OVERRIDE;
 
   std::string hash_val_;
   uint32_t grammar_id_;
@@ -617,6 +617,7 @@ class ApplicationImpl : public virtual Application,
   Timer audio_stream_suspend_timer_;
 
   std::list<AppExtensionPtr> extensions_;
+  mutable std::shared_ptr<sync_primitives::RecursiveLock> extensions_lock_;
 
   // Cloud app properties
   std::string endpoint_;
@@ -644,7 +645,6 @@ class ApplicationImpl : public virtual Application,
   CommandSoftButtonID cmd_softbuttonid_;
   // Lock for command soft button id
   sync_primitives::Lock cmd_softbuttonid_lock_;
-  mutable std::shared_ptr<sync_primitives::Lock> vi_lock_ptr_;
   mutable std::shared_ptr<sync_primitives::Lock> button_lock_ptr_;
   std::string folder_name_;
   ApplicationManager& application_manager_;
diff --git a/src/components/application_manager/include/application_manager/application_manager_impl.h b/src/components/application_manager/include/application_manager/application_manager_impl.h
index d72508bd63..0770cba4b1 100644
--- a/src/components/application_manager/include/application_manager/application_manager_impl.h
+++ b/src/components/application_manager/include/application_manager/application_manager_impl.h
@@ -1023,8 +1023,6 @@ class ApplicationManagerImpl
     rpc_service_ = std::move(rpc_service);
   }
 
-  bool is_stopping() const OVERRIDE;
-
   bool is_audio_pass_thru_active() const OVERRIDE;
   /*
    * @brief Function Should be called when Low Voltage is occured
diff --git a/src/components/application_manager/include/application_manager/commands/command.h b/src/components/application_manager/include/application_manager/commands/command.h
index f8bc66df2a..1283db0edc 100644
--- a/src/components/application_manager/include/application_manager/commands/command.h
+++ b/src/components/application_manager/include/application_manager/commands/command.h
@@ -137,6 +137,8 @@ class Command {
    */
   virtual void SetAllowedToTerminate(const bool allowed) = 0;
 
+  virtual const ApplicationManager& GetApplicationManager() const = 0;
+
   enum CommandSource {
     SOURCE_SDL,
     SOURCE_MOBILE,
diff --git a/src/components/application_manager/include/application_manager/commands/command_impl.h b/src/components/application_manager/include/application_manager/commands/command_impl.h
index 534f07aa37..0438ffe682 100644
--- a/src/components/application_manager/include/application_manager/commands/command_impl.h
+++ b/src/components/application_manager/include/application_manager/commands/command_impl.h
@@ -182,6 +182,8 @@ class CommandImpl : public Command {
    */
   void SetAllowedToTerminate(const bool allowed) OVERRIDE;
 
+  const ApplicationManager& GetApplicationManager() const OVERRIDE;
+
   void OnUpdateTimeOut() OVERRIDE;
 
   /**
diff --git a/src/components/application_manager/src/application_impl.cc b/src/components/application_manager/src/application_impl.cc
index e4a5304a1b..96a5128691 100644
--- a/src/components/application_manager/src/application_impl.cc
+++ b/src/components/application_manager/src/application_impl.cc
@@ -148,8 +148,8 @@ ApplicationImpl::ApplicationImpl(
           "AudioStreamSuspend",
           new ::timer::TimerTaskImpl<ApplicationImpl>(
               this, &ApplicationImpl::OnAudioStreamSuspend))
+    , extensions_lock_(std::make_shared<sync_primitives::RecursiveLock>())
     , hybrid_app_preference_(mobile_api::HybridAppPreference::INVALID_ENUM)
-    , vi_lock_ptr_(std::make_shared<sync_primitives::Lock>())
     , button_lock_ptr_(std::make_shared<sync_primitives::Lock>())
     , application_manager_(application_manager) {
   cmd_number_to_time_limits_[mobile_apis::FunctionID::ReadDIDID] = {
@@ -178,12 +178,28 @@ ApplicationImpl::~ApplicationImpl() {
     active_message_ = NULL;
   }
 
+  button_lock_ptr_->Acquire();
   subscribed_buttons_.clear();
+  button_lock_ptr_->Release();
+  {
+    sync_primitives::AutoLock lock(cmd_softbuttonid_lock_);
+    cmd_softbuttonid_.clear();
+  }
+  cmd_number_to_time_limits_.clear();
+
   if (is_perform_interaction_active()) {
     set_perform_interaction_active(0);
     set_perform_interaction_mode(-1);
   }
   CleanupFiles();
+  {
+    sync_primitives::AutoLock lock(mobile_message_lock_);
+    mobile_message_queue_.clear();
+  }
+  {
+    sync_primitives::AutoLock lock(extensions_lock_);
+    extensions_.clear();
+  }
 }
 
 void ApplicationImpl::CloseActiveMessage() {
@@ -1301,6 +1317,7 @@ void ApplicationImpl::set_hmi_level(
 }
 
 AppExtensionPtr ApplicationImpl::QueryInterface(AppExtensionUID uid) {
+  sync_primitives::AutoLock auto_lock_list(extensions_lock_);
   std::list<AppExtensionPtr>::const_iterator it = extensions_.begin();
   for (; it != extensions_.end(); ++it) {
     if ((*it)->uid() == uid) {
@@ -1315,7 +1332,9 @@ bool ApplicationImpl::AddExtension(AppExtensionPtr extension) {
   if (!QueryInterface(extension->uid())) {
     SDL_LOG_TRACE("Add extenstion to add id" << app_id() << " with uid "
                                              << extension->uid());
+    extensions_lock_->Acquire();
     extensions_.push_back(extension);
+    extensions_lock_->Release();
     return true;
   }
   return false;
@@ -1323,6 +1342,7 @@ bool ApplicationImpl::AddExtension(AppExtensionPtr extension) {
 
 bool ApplicationImpl::RemoveExtension(AppExtensionUID uid) {
   SDL_LOG_AUTO_TRACE();
+  sync_primitives::AutoLock auto_lock_list(extensions_lock_);
   auto it = std::find_if(
       extensions_.begin(), extensions_.end(), [uid](AppExtensionPtr extension) {
         return extension->uid() == uid;
@@ -1336,8 +1356,11 @@ bool ApplicationImpl::RemoveExtension(AppExtensionUID uid) {
   return false;
 }
 
-const std::list<AppExtensionPtr>& ApplicationImpl::Extensions() const {
-  return extensions_;
+const DataAccessor<std::list<AppExtensionPtr> > ApplicationImpl::Extensions()
+    const {
+  DataAccessor<std::list<AppExtensionPtr> > accessor(extensions_,
+                                                     extensions_lock_);
+  return accessor;
 }
 
 const std::string& ApplicationImpl::cloud_app_endpoint() const {
diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc
index e88fb42d8a..6b14388b65 100644
--- a/src/components/application_manager/src/application_manager_impl.cc
+++ b/src/components/application_manager/src/application_manager_impl.cc
@@ -256,8 +256,35 @@ ApplicationManagerImpl::~ApplicationManagerImpl() {
     streaming_timer_pool_.clear();
   }
 
+  {
+    sync_primitives::AutoLock lock(navi_service_status_lock_);
+    navi_service_status_.clear();
+  }
+
+  {
+    sync_primitives::AutoLock lock(tts_global_properties_app_list_lock_);
+    tts_global_properties_app_list_.clear();
+  }
+
+  {
+    sync_primitives::AutoLock lock(apps_to_register_list_lock_ptr_);
+    apps_to_register_.clear();
+  }
+
+  {
+    sync_primitives::AutoLock lock(reregister_wait_list_lock_ptr_);
+    reregister_wait_list_.clear();
+  }
+
+  {
+    sync_primitives::AutoLock lock(query_apps_devices_lock_);
+    query_apps_devices_.clear();
+  }
   clear_pool_timer_.Stop();
   secondary_transport_devices_cache_.clear();
+  applications_list_lock_ptr_->Acquire();
+  applications_.clear();
+  applications_list_lock_ptr_->Release();
 }
 
 DataAccessor<ApplicationSet> ApplicationManagerImpl::applications() const {
@@ -984,7 +1011,7 @@ void ApplicationManagerImpl::RefreshCloudAppInformation() {
   return;
 #else
   SDL_LOG_AUTO_TRACE();
-  if (is_stopping()) {
+  if (IsStopping()) {
     return;
   }
   std::vector<std::string> enabled_apps;
@@ -3504,10 +3531,6 @@ mobile_apis::Result::eType ApplicationManagerImpl::CheckPolicyPermissions(
   return mobile_api::Result::SUCCESS;
 }
 
-bool ApplicationManagerImpl::is_stopping() const {
-  return is_stopping_;
-}
-
 bool ApplicationManagerImpl::is_audio_pass_thru_active() const {
   return audio_pass_thru_active_;
 }
diff --git a/src/components/application_manager/src/commands/command_impl.cc b/src/components/application_manager/src/commands/command_impl.cc
index 34c2a6d6bc..7907cea2ab 100644
--- a/src/components/application_manager/src/commands/command_impl.cc
+++ b/src/components/application_manager/src/commands/command_impl.cc
@@ -174,6 +174,10 @@ void CommandImpl::SetAllowedToTerminate(const bool allowed) {
   allowed_to_terminate_ = allowed;
 }
 
+const ApplicationManager& CommandImpl::GetApplicationManager() const {
+  return application_manager_;
+}
+
 bool CommandImpl::CheckAllowedParameters(const Command::CommandSource source) {
   SDL_LOG_AUTO_TRACE();
 
diff --git a/src/components/application_manager/src/request_controller_impl.cc b/src/components/application_manager/src/request_controller_impl.cc
index 79458566dc..e331ea89e9 100644
--- a/src/components/application_manager/src/request_controller_impl.cc
+++ b/src/components/application_manager/src/request_controller_impl.cc
@@ -72,6 +72,24 @@ RequestControllerImpl::RequestControllerImpl(
 RequestControllerImpl::~RequestControllerImpl() {
   SDL_LOG_AUTO_TRACE();
   Stop();
+
+  retained_mobile_requests_.clear();
+
+  {
+    sync_primitives::AutoLock auto_lock_list(notification_list_lock_);
+    notification_list_.clear();
+  }
+
+  {
+    sync_primitives::AutoLock auto_lock_list(duplicate_message_count_lock_);
+    duplicate_message_count_.clear();
+  }
+
+  {
+    sync_primitives::AutoLock auto_lock_list(mobile_request_list_lock_);
+    mobile_request_list_.clear();
+    waiting_for_response_.RemoveMobileRequests();
+  }
 }
 
 void RequestControllerImpl::Stop() {
@@ -111,7 +129,6 @@ void RequestControllerImpl::InitializeThreadpool() {
 void RequestControllerImpl::DestroyThreadpool() {
   SDL_LOG_AUTO_TRACE();
   {
-    AutoLock auto_lock(mobile_request_list_lock_);
     pool_state_ = TPoolState::STOPPED;
     SDL_LOG_DEBUG("Broadcasting STOP signal to all threads...");
     cond_var_.Broadcast();  // notify all threads we are shutting down
@@ -159,7 +176,9 @@ bool RequestControllerImpl::CheckPendingRequestsAmount(
   SDL_LOG_AUTO_TRACE();
 
   if (pending_requests_amount > 0) {
+    mobile_request_list_lock_.Acquire();
     const size_t pending_requests_size = mobile_request_list_.size();
+    mobile_request_list_lock_.Release();
     const bool available_to_add =
         pending_requests_amount > pending_requests_size;
     if (!available_to_add) {
@@ -181,11 +200,12 @@ RequestController::TResult RequestControllerImpl::AddMobileRequest(
     cond_var_.NotifyOne();
     return TResult::INVALID_DATA;
   }
+
   SDL_LOG_DEBUG("correlation_id : " << request->correlation_id()
                                     << "connection_key : "
                                     << request->connection_key());
   RequestController::TResult result = CheckPosibilitytoAdd(request, hmi_level);
-  if (TResult::SUCCESS == result) {
+  if (TResult::SUCCESS == result && TPoolState::STOPPED != pool_state_) {
     AutoLock auto_lock_list(mobile_request_list_lock_);
     mobile_request_list_.push_back(request);
     SDL_LOG_DEBUG("Waiting for execution: " << mobile_request_list_.size());
@@ -431,11 +451,13 @@ void RequestControllerImpl::TerminateWaitingForResponseAppRequests(
 
 void RequestControllerImpl::TerminateAppRequests(const uint32_t app_id) {
   SDL_LOG_AUTO_TRACE();
+  mobile_request_list_lock_.Acquire();
   SDL_LOG_DEBUG("app_id : " << app_id
                             << "Requests waiting for execution count : "
                             << mobile_request_list_.size()
                             << "Requests waiting for response count : "
                             << waiting_for_response_.Size());
+  mobile_request_list_lock_.Release();
 
   TerminateWaitingForExecutionAppRequests(app_id);
   TerminateWaitingForResponseAppRequests(app_id);
@@ -452,8 +474,9 @@ void RequestControllerImpl::TerminateAllMobileRequests() {
 
   waiting_for_response_.RemoveMobileRequests();
   SDL_LOG_DEBUG("Mobile Requests waiting for response cleared");
-  AutoLock waiting_execution_auto_lock(mobile_request_list_lock_);
+  mobile_request_list_lock_.Acquire();
   mobile_request_list_.clear();
+  mobile_request_list_lock_.Release();
   SDL_LOG_DEBUG("Mobile Requests waiting for execution cleared");
   NotifyTimer();
 }
@@ -590,27 +613,32 @@ RequestControllerImpl::Worker::~Worker() {}
 
 void RequestControllerImpl::Worker::threadMain() {
   SDL_LOG_AUTO_TRACE();
-  AutoLock auto_lock(thread_lock_);
+  AutoLock auto_thread_lock_(thread_lock_);
   while (!stop_flag_) {
     // Try to pick a request
-    AutoLock auto_lock(request_controller_->mobile_request_list_lock_);
+    request_controller_->mobile_request_list_lock_.Acquire();
 
     while ((request_controller_->pool_state_ != TPoolState::STOPPED) &&
            (request_controller_->mobile_request_list_.empty())) {
       // Wait until there is a task in the queue
       // Unlock mutex while wait, then lock it back when signaled
       SDL_LOG_INFO("Unlocking and waiting");
-      request_controller_->cond_var_.Wait(auto_lock);
+      request_controller_->cond_var_.Wait(
+          request_controller_->mobile_request_list_lock_);
       SDL_LOG_INFO("Signaled and locking");
     }
 
     // If the thread was shutdown, return from here
     if (request_controller_->pool_state_ == TPoolState::STOPPED) {
+      SDL_LOG_WARN("TPoolState::STOPPED");
+      request_controller_->mobile_request_list_.clear();
+      request_controller_->mobile_request_list_lock_.Release();
       break;
     }
 
     if (request_controller_->mobile_request_list_.empty()) {
       SDL_LOG_WARN("Mobile request list is empty");
+      request_controller_->mobile_request_list_lock_.Release();
       break;
     }
 
@@ -640,6 +668,7 @@ void RequestControllerImpl::Worker::threadMain() {
         cmd_request->SendResponse(
             false, mobile_apis::Result::INVALID_ID, "Duplicate correlation_id");
       }
+      request_controller_->mobile_request_list_lock_.Release();
       continue;
     }
     SDL_LOG_DEBUG("timeout_in_mseconds " << timeout_in_mseconds);
@@ -653,7 +682,7 @@ void RequestControllerImpl::Worker::threadMain() {
           "of this request.");
     }
 
-    AutoUnlock unlock(auto_lock);
+    request_controller_->mobile_request_list_lock_.Release();
 
     // execute
     if ((false == request_controller_->IsLowVoltage()) &&
@@ -663,6 +692,12 @@ void RequestControllerImpl::Worker::threadMain() {
                     << " with timeout: " << timeout_in_mseconds);
       request_ptr->Run();
     }
+    if (request_ptr->GetApplicationManager().IsStopping()) {
+      request_controller_->mobile_request_list_lock_.Acquire();
+      request_controller_->mobile_request_list_.clear();
+      request_controller_->waiting_for_response_.RemoveMobileRequests();
+      request_controller_->mobile_request_list_lock_.Release();
+    }
   }
 }
 
diff --git a/src/components/application_manager/src/resumption/resumption_data.cc b/src/components/application_manager/src/resumption/resumption_data.cc
index 50b95dba42..0663237c43 100644
--- a/src/components/application_manager/src/resumption/resumption_data.cc
+++ b/src/components/application_manager/src/resumption/resumption_data.cc
@@ -163,7 +163,8 @@ smart_objects::SmartObject ResumptionData::GetApplicationSubscriptions(
            subscriptions);
   }
 
-  for (auto extension : application->Extensions()) {
+  auto extensions = application->Extensions();
+  for (auto& extension : extensions.GetData()) {
     extension->SaveResumptionData(subscriptions);
   }
 
diff --git a/src/components/application_manager/src/resumption/resumption_data_processor_impl.cc b/src/components/application_manager/src/resumption/resumption_data_processor_impl.cc
index 7d65ce75c2..996b4f3026 100644
--- a/src/components/application_manager/src/resumption/resumption_data_processor_impl.cc
+++ b/src/components/application_manager/src/resumption/resumption_data_processor_impl.cc
@@ -899,7 +899,8 @@ void ResumptionDataProcessorImpl::AddPluginsSubscriptions(
     const smart_objects::SmartObject& saved_app) {
   SDL_LOG_AUTO_TRACE();
 
-  for (auto& extension : application->Extensions()) {
+  auto extensions = application->Extensions();
+  for (auto& extension : extensions.GetData()) {
     extension->ProcessResumption(saved_app);
   }
 }
@@ -1004,7 +1005,7 @@ void ResumptionDataProcessorImpl::DeletePluginsSubscriptions(
   resumption_status_lock_.Release();
 
   auto extensions = application->Extensions();
-  for (auto& extension : extensions) {
+  for (auto& extension : extensions.GetData()) {
     extension->RevertResumption(resumption_data_to_revert);
   }
 }
diff --git a/src/components/application_manager/src/rpc_handler_impl.cc b/src/components/application_manager/src/rpc_handler_impl.cc
index b6b9f2e16b..3e0a600d72 100644
--- a/src/components/application_manager/src/rpc_handler_impl.cc
+++ b/src/components/application_manager/src/rpc_handler_impl.cc
@@ -212,7 +212,7 @@ void RPCHandlerImpl::Handle(const impl::MessageFromMobile message) {
     SDL_LOG_ERROR("Null-pointer message received.");
     return;
   }
-  if (app_manager_.is_stopping()) {
+  if (app_manager_.IsStopping()) {
     SDL_LOG_INFO("Application manager is stopping");
     return;
   }
diff --git a/src/components/application_manager/test/include/application_manager/mock_application.h b/src/components/application_manager/test/include/application_manager/mock_application.h
index e94ffa5961..5568db4dd1 100644
--- a/src/components/application_manager/test/include/application_manager/mock_application.h
+++ b/src/components/application_manager/test/include/application_manager/mock_application.h
@@ -404,8 +404,9 @@ class MockApplication : public ::application_manager::Application {
   MOCK_METHOD1(AddExtension,
                bool(application_manager::AppExtensionPtr extention));
   MOCK_METHOD1(RemoveExtension, bool(application_manager::AppExtensionUID uid));
-  MOCK_CONST_METHOD0(Extensions,
-                     const std::list<application_manager::AppExtensionPtr>&());
+  MOCK_CONST_METHOD0(
+      Extensions,
+      const DataAccessor<std::list<application_manager::AppExtensionPtr> >());
   MOCK_CONST_METHOD0(is_remote_control_supported, bool());
   MOCK_METHOD1(set_remote_control_supported, void(const bool allow));
   MOCK_CONST_METHOD0(cloud_app_endpoint, const std::string&());
diff --git a/src/components/application_manager/test/include/application_manager/mock_request.h b/src/components/application_manager/test/include/application_manager/mock_request.h
index 4348e39020..098002f15d 100644
--- a/src/components/application_manager/test/include/application_manager/mock_request.h
+++ b/src/components/application_manager/test/include/application_manager/mock_request.h
@@ -63,6 +63,8 @@ class MockRequest : public application_manager::commands::Command {
   MOCK_METHOD0(AllowedToTerminate, bool());
   MOCK_METHOD1(SetAllowedToTerminate, void(bool is_allowed));
 
+  MOCK_CONST_METHOD0(GetApplicationManager,
+                     application_manager::ApplicationManager&());
   MOCK_CONST_METHOD0(connection_key, uint32_t());
   MOCK_CONST_METHOD0(correlation_id, uint32_t());
 };
diff --git a/src/components/application_manager/test/include/application_manager/resumption_data_test.h b/src/components/application_manager/test/include/application_manager/resumption_data_test.h
index bea920e44e..93fa6bcae9 100644
--- a/src/components/application_manager/test/include/application_manager/resumption_data_test.h
+++ b/src/components/application_manager/test/include/application_manager/resumption_data_test.h
@@ -75,6 +75,7 @@ class ResumptionDataTest : public ::testing::Test {
       , setlock_ptr_(std::make_shared<sync_primitives::Lock>())
       , btnlock_ptr_(std::make_shared<sync_primitives::Lock>())
       , ivilock_ptr_(std::make_shared<sync_primitives::Lock>())
+      , extensions_lock_(std::make_shared<sync_primitives::RecursiveLock>())
       , window_params_map_lock_ptr_(std::make_shared<sync_primitives::Lock>()) {
   }
   virtual ~ResumptionDataTest();
@@ -162,6 +163,7 @@ class ResumptionDataTest : public ::testing::Test {
   std::shared_ptr<sync_primitives::Lock> setlock_ptr_;
   std::shared_ptr<sync_primitives::Lock> btnlock_ptr_;
   std::shared_ptr<sync_primitives::Lock> ivilock_ptr_;
+  std::shared_ptr<sync_primitives::RecursiveLock> extensions_lock_;
   std::shared_ptr<sync_primitives::Lock> window_params_map_lock_ptr_;
   application_manager_test::MockApplicationManagerSettings
       mock_application_manager_settings_;
diff --git a/src/components/application_manager/test/request_controller/request_controller_test.cc b/src/components/application_manager/test/request_controller/request_controller_test.cc
index 2de2a69cf7..976dfb44e7 100644
--- a/src/components/application_manager/test/request_controller/request_controller_test.cc
+++ b/src/components/application_manager/test/request_controller/request_controller_test.cc
@@ -45,7 +45,6 @@
 #include "application_manager/event_engine/event_dispatcher.h"
 #include "application_manager/mock_application_manager.h"
 
-#include "application_manager/mock_application_manager.h"
 #include "application_manager/mock_request_controller_settings.h"
 #include "application_manager/mock_request_timeout_handler.h"
 #include "application_manager/policies/policy_handler.h"
@@ -62,6 +61,7 @@ namespace request_controller_test {
 using ::application_manager::request_controller::RequestController;
 using ::application_manager::request_controller::RequestControllerImpl;
 using ::application_manager::request_controller::RequestInfo;
+using ::test::components::application_manager_test::MockApplicationManager;
 using test::components::application_manager_test::MockRequestTimeoutHandler;
 
 using ::test::components::event_engine_test::MockEventDispatcher;
@@ -168,6 +168,7 @@ class RequestControllerTestClass : public ::testing::Test {
   RequestControllerSPtr request_ctrl_;
   RequestPtr empty_mock_request_;
   const TestSettings default_settings_;
+  NiceMock<MockApplicationManager> app_mngr_;
 };
 
 TEST_F(RequestControllerTestClass,
@@ -179,6 +180,10 @@ TEST_F(RequestControllerTestClass,
   EXPECT_CALL(*request_valid, Run())
       .Times(1)
       .WillRepeatedly(NotifyTestAsyncWaiter(waiter_valid));
+  EXPECT_CALL(*request_valid, GetApplicationManager())
+      .Times(1)
+      .WillRepeatedly(ReturnRef(app_mngr_));
+  EXPECT_CALL(app_mngr_, IsStopping()).Times(1).WillRepeatedly(Return(false));
 
   EXPECT_EQ(RequestController::TResult::SUCCESS,
             AddRequest(default_settings_,
@@ -211,40 +216,18 @@ TEST_F(RequestControllerTestClass,
   // app_hmi_level_none_time_scale_max_requests_ equals 0
   // (in the default settings they setted to 0)
   for (size_t i = 0; i < kMaxRequestAmount; ++i) {
+    RequestPtr request_valid = GetMockRequest(i);
+    EXPECT_CALL(*request_valid, GetApplicationManager())
+        .WillRepeatedly(ReturnRef(app_mngr_));
+    EXPECT_CALL(app_mngr_, IsStopping()).WillRepeatedly(Return(false));
     EXPECT_EQ(RequestController::TResult::SUCCESS,
               AddRequest(default_settings_,
-                         GetMockRequest(i),
+                         request_valid,
                          RequestInfo::RequestType::MobileRequest,
                          mobile_apis::HMILevel::HMI_FULL));
   }
 }
 
-TEST_F(
-    RequestControllerTestClass,
-    CheckPosibilitytoAdd_ExcessPendingRequestsAmount_TooManyPendingRequests) {
-  TestSettings settings;
-  settings.pending_requests_amount_ = kNumberOfRequests;
-
-  request_ctrl_->DestroyThreadpool();
-
-  // Adding requests to fit in pending_requests_amount_
-  for (size_t i = 0; i < kNumberOfRequests; ++i) {
-    EXPECT_EQ(RequestController::TResult::SUCCESS,
-              AddRequest(settings,
-                         GetMockRequest(),
-                         RequestInfo::RequestType::MobileRequest,
-                         mobile_apis::HMILevel::HMI_FULL));
-  }
-
-  // Trying to add one more extra request
-  // Expect overflow and TOO_MANY_PENDING_REQUESTS result
-  EXPECT_EQ(RequestController::TResult::TOO_MANY_PENDING_REQUESTS,
-            AddRequest(settings,
-                       GetMockRequest(),
-                       RequestInfo::RequestType::MobileRequest,
-                       mobile_apis::HMILevel::HMI_FULL));
-}
-
 TEST_F(RequestControllerTestClass, IsLowVoltage_SetOnLowVoltage_TRUE) {
   request_ctrl_->OnLowVoltage();
   const bool result = true;
@@ -258,11 +241,23 @@ TEST_F(RequestControllerTestClass, IsLowVoltage_SetOnWakeUp_FALSE) {
 }
 
 TEST_F(RequestControllerTestClass, AddMobileRequest_SetValidData_SUCCESS) {
+  RequestPtr request_valid = GetMockRequest();
+  auto waiter_valid = TestAsyncWaiter::createInstance();
+  ON_CALL(*request_valid, default_timeout()).WillByDefault(Return(0));
+  EXPECT_CALL(*request_valid, Init()).WillOnce(Return(true));
+  EXPECT_CALL(*request_valid, Run())
+      .Times(1)
+      .WillRepeatedly(NotifyTestAsyncWaiter(waiter_valid));
+  EXPECT_CALL(*request_valid, GetApplicationManager())
+      .Times(1)
+      .WillRepeatedly(ReturnRef(app_mngr_));
+  EXPECT_CALL(app_mngr_, IsStopping()).Times(1).WillRepeatedly(Return(false));
   EXPECT_EQ(RequestController::TResult::SUCCESS,
             AddRequest(default_settings_,
-                       GetMockRequest(),
+                       request_valid,
                        RequestInfo::RequestType::MobileRequest,
                        mobile_apis::HMILevel::HMI_FULL));
+  EXPECT_TRUE(waiter_valid->WaitFor(1, 1000));
 }
 
 TEST_F(RequestControllerTestClass,
@@ -292,6 +287,10 @@ TEST_F(RequestControllerTestClass, OnTimer_SUCCESS) {
   const uint32_t request_timeout = 1u;
   RequestPtr mock_request = GetMockRequest(
       kDefaultCorrelationID, kDefaultConnectionKey, request_timeout);
+  EXPECT_CALL(*mock_request, GetApplicationManager())
+      .Times(1)
+      .WillRepeatedly(ReturnRef(app_mngr_));
+  EXPECT_CALL(app_mngr_, IsStopping()).Times(1).WillRepeatedly(Return(false));
 
   auto waiter = TestAsyncWaiter::createInstance();
   EXPECT_EQ(RequestController::TResult::SUCCESS,
diff --git a/src/components/application_manager/test/resumption/resume_ctrl_test.cc b/src/components/application_manager/test/resumption/resume_ctrl_test.cc
index 1ff04c332c..010cd0bf05 100644
--- a/src/components/application_manager/test/resumption/resume_ctrl_test.cc
+++ b/src/components/application_manager/test/resumption/resume_ctrl_test.cc
@@ -98,7 +98,8 @@ class ResumeCtrlTest : public ::testing::Test {
       , kDefaultDeferredTestLevel_(eType::INVALID_ENUM)
       , kNaviLowbandwidthLevel_("LIMITED")
       , kProjectionLowbandwidthLevel_("NONE")
-      , kMediaLowbandwidthLevel_("NONE") {
+      , kMediaLowbandwidthLevel_("NONE")
+      , extensions_lock_(std::make_shared<sync_primitives::RecursiveLock>()) {
     profile::Profile profile_;
     profile_.set_config_file_name("smartDeviceLink.ini");
     resumption_delay_before_ign_ = profile_.resumption_delay_before_ign();
@@ -245,6 +246,7 @@ class ResumeCtrlTest : public ::testing::Test {
   const std::string kMediaLowbandwidthLevel_;
   NiceMock<application_manager_test::MockRPCService> mock_rpc_service_;
   resumption::ResumeCtrl::ResumptionCallBack callback_;
+  std::shared_ptr<sync_primitives::RecursiveLock> extensions_lock_;
 };
 
 /**
@@ -327,7 +329,9 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithFiles) {
       .WillRepeatedly(Return(requests));
   std::list<application_manager::AppExtensionPtr> extensions;
   extensions.insert(extensions.begin(), mock_app_extension_);
-  EXPECT_CALL(*mock_app_, Extensions()).WillOnce(ReturnRef(extensions));
+  DataAccessor<std::list<application_manager::AppExtensionPtr> > accessor(
+      extensions, extensions_lock_);
+  EXPECT_CALL(*mock_app_, Extensions()).WillOnce(Return(accessor));
   EXPECT_CALL(*mock_app_, set_grammar_id(kTestGrammarId_));
   for (uint32_t i = 0; i < count_of_files; ++i) {
     EXPECT_CALL(*mock_app_,
@@ -387,7 +391,9 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithSubmenues) {
 
   std::list<application_manager::AppExtensionPtr> extensions;
   extensions.insert(extensions.begin(), mock_app_extension_);
-  EXPECT_CALL(*mock_app_, Extensions()).WillOnce(ReturnRef(extensions));
+  DataAccessor<std::list<application_manager::AppExtensionPtr> > accessor(
+      extensions, extensions_lock_);
+  EXPECT_CALL(*mock_app_, Extensions()).WillOnce(Return(accessor));
 
   const bool res = res_ctrl_->StartResumption(mock_app_, kHash_, callback_);
   EXPECT_TRUE(res);
@@ -461,7 +467,9 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithCommands) {
       .WillRepeatedly(Return(requests));
   std::list<application_manager::AppExtensionPtr> extensions;
   extensions.insert(extensions.begin(), mock_app_extension_);
-  EXPECT_CALL(*mock_app_, Extensions()).WillOnce(ReturnRef(extensions));
+  DataAccessor<std::list<application_manager::AppExtensionPtr> > accessor(
+      extensions, extensions_lock_);
+  EXPECT_CALL(*mock_app_, Extensions()).WillOnce(Return(accessor));
 
   const bool res = res_ctrl_->StartResumption(mock_app_, kHash_, callback_);
   EXPECT_TRUE(res);
@@ -521,7 +529,9 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithChoiceSet) {
 
   std::list<application_manager::AppExtensionPtr> extensions;
   extensions.insert(extensions.begin(), mock_app_extension_);
-  EXPECT_CALL(*mock_app_, Extensions()).WillOnce(ReturnRef(extensions));
+  DataAccessor<std::list<application_manager::AppExtensionPtr> > accessor(
+      extensions, extensions_lock_);
+  EXPECT_CALL(*mock_app_, Extensions()).WillOnce(Return(accessor));
 
   const bool res = res_ctrl_->StartResumption(mock_app_, kHash_, callback_);
   EXPECT_TRUE(res);
@@ -560,9 +570,12 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithGlobalProperties) {
   EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(),
               CreateAddCommandRequestToHMI(_, _))
       .WillRepeatedly(Return(requests));
+
   std::list<application_manager::AppExtensionPtr> extensions;
   extensions.insert(extensions.begin(), mock_app_extension_);
-  EXPECT_CALL(*mock_app_, Extensions()).WillOnce(ReturnRef(extensions));
+  DataAccessor<std::list<application_manager::AppExtensionPtr> > accessor(
+      extensions, extensions_lock_);
+  EXPECT_CALL(*mock_app_, Extensions()).WillOnce(Return(accessor));
   const bool res = res_ctrl_->StartResumption(mock_app_, kHash_, callback_);
   EXPECT_TRUE(res);
 }
@@ -613,8 +626,9 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithSubscribeOnButtons) {
 
   std::list<application_manager::AppExtensionPtr> extensions;
   extensions.insert(extensions.begin(), mock_app_extension_);
-
-  EXPECT_CALL(*mock_app_, Extensions()).WillOnce(ReturnRef(extensions));
+  DataAccessor<std::list<application_manager::AppExtensionPtr> > accessor(
+      extensions, extensions_lock_);
+  EXPECT_CALL(*mock_app_, Extensions()).WillOnce(Return(accessor));
 
   EXPECT_CALL(*mock_app_extension_, ProcessResumption(saved_app));
   EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(),
@@ -660,10 +674,11 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithSubscriptionToIVI) {
   smart_objects::SmartObjectList requests;
 
   std::list<application_manager::AppExtensionPtr> extensions;
-
   extensions.insert(extensions.begin(), mock_app_extension_);
 
-  EXPECT_CALL(*mock_app_, Extensions()).WillOnce(ReturnRef(extensions));
+  DataAccessor<std::list<application_manager::AppExtensionPtr> > accessor(
+      extensions, extensions_lock_);
+  EXPECT_CALL(*mock_app_, Extensions()).WillOnce(Return(accessor));
 
   EXPECT_CALL(*mock_app_extension_, ProcessResumption(saved_app));
   const bool res = res_ctrl_->StartResumption(mock_app_, kHash_, callback_);
@@ -693,7 +708,6 @@ TEST_F(ResumeCtrlTest,
   std::list<application_manager::AppExtensionPtr> extensions;
   // It will work only for WayPointsAppExtension, need to rework this test
   extensions.insert(extensions.begin(), mock_app_extension_);
-  EXPECT_CALL(*mock_app_, Extensions()).WillOnce(ReturnRef(extensions));
 
   EXPECT_CALL(mock_app_mngr_,
               SubscribeAppForWayPoints(
diff --git a/src/components/application_manager/test/resumption/resumption_data_test.cc b/src/components/application_manager/test/resumption/resumption_data_test.cc
index cb5a4d9a56..603af4ca47 100644
--- a/src/components/application_manager/test/resumption/resumption_data_test.cc
+++ b/src/components/application_manager/test/resumption/resumption_data_test.cc
@@ -383,7 +383,9 @@ void ResumptionDataTest::PrepareData() {
   mock_app_extension_ =
       std::make_shared<NiceMock<application_manager_test::MockAppExtension> >();
   extensions_.insert(extensions_.begin(), mock_app_extension_);
-  ON_CALL(*app_mock, Extensions()).WillByDefault(ReturnRef(extensions_));
+  DataAccessor<std::list<application_manager::AppExtensionPtr> > accessor(
+      extensions_, extensions_lock_);
+  ON_CALL(*app_mock, Extensions()).WillByDefault(Return(accessor));
   SetGlobalProporties();
   SetCommands();
   SetSubmenues();
diff --git a/src/components/include/application_manager/application_manager.h b/src/components/include/application_manager/application_manager.h
index a0092b93df..9c19059863 100644
--- a/src/components/include/application_manager/application_manager.h
+++ b/src/components/include/application_manager/application_manager.h
@@ -512,7 +512,6 @@ class ApplicationManager {
   get_request_timeout_handler() const = 0;
   virtual request_controller::RequestController& get_request_controller()
       const = 0;
-  virtual bool is_stopping() const = 0;
   virtual bool is_audio_pass_thru_active() const = 0;
 
   virtual uint32_t GetNextMobileCorrelationID() = 0;
diff --git a/src/components/include/test/application_manager/mock_application_manager.h b/src/components/include/test/application_manager/mock_application_manager.h
index dfc9cbab5a..1161009feb 100644
--- a/src/components/include/test/application_manager/mock_application_manager.h
+++ b/src/components/include/test/application_manager/mock_application_manager.h
@@ -197,7 +197,7 @@ class MockApplicationManager : public application_manager::ApplicationManager {
   MOCK_CONST_METHOD0(
       get_request_controller,
       application_manager::request_controller::RequestController&());
-  MOCK_CONST_METHOD0(is_stopping, bool());
+  MOCK_CONST_METHOD0(IsStopping, bool());
   MOCK_CONST_METHOD0(is_audio_pass_thru_active, bool());
   MOCK_METHOD0(GetNextHMICorrelationID, uint32_t());
   MOCK_METHOD0(GetNextMobileCorrelationID, uint32_t());
@@ -236,7 +236,6 @@ class MockApplicationManager : public application_manager::ApplicationManager {
                     bool is_greyed_out));
   MOCK_CONST_METHOD1(IsAppsQueriedFrom,
                      bool(const connection_handler::DeviceHandle handle));
-  MOCK_CONST_METHOD0(IsStopping, bool());
   MOCK_METHOD0(WaitForHmiIsReady, bool());
   MOCK_METHOD1(RemoveAppFromTTSGlobalPropertiesList,
                void(const uint32_t app_id));
diff --git a/src/components/transport_manager/src/transport_adapter/transport_adapter_impl.cc b/src/components/transport_manager/src/transport_adapter/transport_adapter_impl.cc
index c6412fe141..d335987a52 100644
--- a/src/components/transport_manager/src/transport_adapter/transport_adapter_impl.cc
+++ b/src/components/transport_manager/src/transport_adapter/transport_adapter_impl.cc
@@ -137,6 +137,7 @@ void TransportAdapterImpl::Terminate() {
   connections_lock_.AcquireForWriting();
   std::swap(connections, connections_);
   connections_lock_.Release();
+
   for (const auto& connection : connections) {
     auto& info = connection.second;
     if (info.connection) {