Convert DataAccessor to use a shared_ptr to a lock

33 files changed, 434 insertions, 345 deletions

diff --git a/src/components/application_manager/include/application_manager/application_data_impl.h b/src/components/application_manager/include/application_manager/application_data_impl.h
index dc9be4e1d8..3b73244754 100644
--- a/src/components/application_manager/include/application_manager/application_data_impl.h
+++ b/src/components/application_manager/include/application_manager/application_data_impl.h
@@ -275,13 +275,13 @@ class DynamicApplicationDataImpl : public virtual Application {
   std::string display_layout_;
 
   CommandsMap commands_;
-  mutable sync_primitives::Lock commands_lock_;
+  mutable std::shared_ptr<sync_primitives::Lock> commands_lock_ptr_;
   SubMenuMap sub_menu_;
-  mutable sync_primitives::Lock sub_menu_lock_;
+  mutable std::shared_ptr<sync_primitives::Lock> sub_menu_lock_ptr_;
   ChoiceSetMap choice_set_map_;
-  mutable sync_primitives::Lock choice_set_map_lock_;
+  mutable std::shared_ptr<sync_primitives::Lock> choice_set_map_lock_ptr_;
   PerformChoiceSetMap performinteraction_choice_set_map_;
-  mutable sync_primitives::Lock performinteraction_choice_set_lock_;
+  mutable std::shared_ptr<sync_primitives::Lock> performinteraction_choice_set_lock_ptr_;
   uint32_t is_perform_interaction_active_;
   bool is_reset_global_properties_active_;
   int32_t perform_interaction_mode_;
@@ -295,21 +295,21 @@ class DynamicApplicationDataImpl : public virtual Application {
 };
 
 DataAccessor<CommandsMap> DynamicApplicationDataImpl::commands_map() const {
-  return DataAccessor<CommandsMap>(commands_, commands_lock_);
+  return DataAccessor<CommandsMap>(commands_, commands_lock_ptr_);
 }
 
 DataAccessor<SubMenuMap> DynamicApplicationDataImpl::sub_menu_map() const {
-  return DataAccessor<SubMenuMap>(sub_menu_, sub_menu_lock_);
+  return DataAccessor<SubMenuMap>(sub_menu_, sub_menu_lock_ptr_);
 }
 
 DataAccessor<ChoiceSetMap> DynamicApplicationDataImpl::choice_set_map() const {
-  return DataAccessor<ChoiceSetMap>(choice_set_map_, choice_set_map_lock_);
+  return DataAccessor<ChoiceSetMap>(choice_set_map_, choice_set_map_lock_ptr_);
 }
 
 DataAccessor<PerformChoiceSetMap>
 DynamicApplicationDataImpl::performinteraction_choice_set_map() const {
   return DataAccessor<PerformChoiceSetMap>(performinteraction_choice_set_map_,
-                                           performinteraction_choice_set_lock_);
+                                           performinteraction_choice_set_lock_ptr_);
 }
 
 uint32_t DynamicApplicationDataImpl::is_perform_interaction_active() const {
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 50e0a209cf..e727fb31b9 100644
--- a/src/components/application_manager/include/application_manager/application_impl.h
+++ b/src/components/application_manager/include/application_manager/application_impl.h
@@ -510,8 +510,8 @@ class ApplicationImpl : public virtual Application,
   CommandSoftButtonID cmd_softbuttonid_;
   // Lock for command soft button id
   sync_primitives::Lock cmd_softbuttonid_lock_;
-  mutable sync_primitives::Lock vi_lock_;
-  sync_primitives::Lock button_lock_;
+  mutable std::shared_ptr<sync_primitives::Lock> vi_lock_ptr_;
+  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 286ad87018..98f0be2420 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
@@ -1698,8 +1698,8 @@ class ApplicationManagerImpl
   ForbiddenApps forbidden_applications;
 
   // Lock for applications list
-  mutable sync_primitives::Lock applications_list_lock_;
-  mutable sync_primitives::Lock apps_to_register_list_lock_;
+  mutable std::shared_ptr<sync_primitives::Lock> applications_list_lock_ptr_;
+  mutable std::shared_ptr<sync_primitives::Lock> apps_to_register_list_lock_ptr_;
   mutable sync_primitives::Lock subscribed_way_points_apps_lock_;
 
   /**
diff --git a/src/components/application_manager/src/application_data_impl.cc b/src/components/application_manager/src/application_data_impl.cc
index 226c83dbf6..f271b7ff6a 100644
--- a/src/components/application_manager/src/application_data_impl.cc
+++ b/src/components/application_manager/src/application_data_impl.cc
@@ -44,6 +44,7 @@ InitialApplicationDataImpl::InitialApplicationDataImpl()
     , vr_synonyms_(NULL)
     , tts_name_(NULL)
     , ngn_media_screen_name_(NULL)
+
     , language_(mobile_api::Language::INVALID_ENUM)
     , ui_language_(mobile_api::Language::INVALID_ENUM) {}
 
@@ -177,11 +178,13 @@ DynamicApplicationDataImpl::DynamicApplicationDataImpl()
     , night_color_scheme_(NULL)
     , display_layout_("")
     , commands_()
-    , commands_lock_(true)
+    , commands_lock_ptr_(new sync_primitives::Lock(true))
     , sub_menu_()
+    , sub_menu_lock_ptr_(std::make_shared<sync_primitives::Lock>())
     , choice_set_map_()
+    , choice_set_map_lock_ptr_(std::make_shared<sync_primitives::Lock>())
     , performinteraction_choice_set_map_()
-    , performinteraction_choice_set_lock_(true)
+    , performinteraction_choice_set_lock_ptr_(new sync_primitives::Lock(true))
     , is_perform_interaction_active_(false)
     , is_reset_global_properties_active_(false)
     , perform_interaction_mode_(-1) {}
@@ -471,7 +474,7 @@ void DynamicApplicationDataImpl::SetGlobalProperties(
 
 void DynamicApplicationDataImpl::AddCommand(
     uint32_t cmd_id, const smart_objects::SmartObject& command) {
-  sync_primitives::AutoLock lock(commands_lock_);
+  sync_primitives::AutoLock lock(commands_lock_ptr_);
   CommandsMap::const_iterator it = commands_.find(cmd_id);
   if (commands_.end() == it) {
     commands_[cmd_id] = new smart_objects::SmartObject(command);
@@ -479,7 +482,7 @@ void DynamicApplicationDataImpl::AddCommand(
 }
 
 void DynamicApplicationDataImpl::RemoveCommand(uint32_t cmd_id) {
-  sync_primitives::AutoLock lock(commands_lock_);
+  sync_primitives::AutoLock lock(commands_lock_ptr_);
   CommandsMap::iterator it = commands_.find(cmd_id);
   if (commands_.end() != it) {
     delete it->second;
@@ -489,7 +492,7 @@ void DynamicApplicationDataImpl::RemoveCommand(uint32_t cmd_id) {
 
 smart_objects::SmartObject* DynamicApplicationDataImpl::FindCommand(
     uint32_t cmd_id) {
-  sync_primitives::AutoLock lock(commands_lock_);
+  sync_primitives::AutoLock lock(commands_lock_ptr_);
   CommandsMap::const_iterator it = commands_.find(cmd_id);
   if (it != commands_.end()) {
     return it->second;
@@ -501,7 +504,7 @@ smart_objects::SmartObject* DynamicApplicationDataImpl::FindCommand(
 // TODO(VS): Create common functions for processing collections
 void DynamicApplicationDataImpl::AddSubMenu(
     uint32_t menu_id, const smart_objects::SmartObject& menu) {
-  sync_primitives::AutoLock lock(sub_menu_lock_);
+  sync_primitives::AutoLock lock(sub_menu_lock_ptr_);
   SubMenuMap::const_iterator it = sub_menu_.find(menu_id);
   if (sub_menu_.end() == it) {
     sub_menu_[menu_id] = new smart_objects::SmartObject(menu);
@@ -509,7 +512,7 @@ void DynamicApplicationDataImpl::AddSubMenu(
 }
 
 void DynamicApplicationDataImpl::RemoveSubMenu(uint32_t menu_id) {
-  sync_primitives::AutoLock lock(sub_menu_lock_);
+  sync_primitives::AutoLock lock(sub_menu_lock_ptr_);
   SubMenuMap::iterator it = sub_menu_.find(menu_id);
 
   if (sub_menu_.end() != it) {
@@ -520,7 +523,7 @@ void DynamicApplicationDataImpl::RemoveSubMenu(uint32_t menu_id) {
 
 smart_objects::SmartObject* DynamicApplicationDataImpl::FindSubMenu(
     uint32_t menu_id) const {
-  sync_primitives::AutoLock lock(sub_menu_lock_);
+  sync_primitives::AutoLock lock(sub_menu_lock_ptr_);
   SubMenuMap::const_iterator it = sub_menu_.find(menu_id);
   if (it != sub_menu_.end()) {
     return it->second;
@@ -531,7 +534,7 @@ smart_objects::SmartObject* DynamicApplicationDataImpl::FindSubMenu(
 
 bool DynamicApplicationDataImpl::IsSubMenuNameAlreadyExist(
     const std::string& name) {
-  sync_primitives::AutoLock lock(sub_menu_lock_);
+  sync_primitives::AutoLock lock(sub_menu_lock_ptr_);
   for (SubMenuMap::iterator it = sub_menu_.begin(); sub_menu_.end() != it;
        ++it) {
     smart_objects::SmartObject* menu = it->second;
@@ -544,7 +547,7 @@ bool DynamicApplicationDataImpl::IsSubMenuNameAlreadyExist(
 
 void DynamicApplicationDataImpl::AddChoiceSet(
     uint32_t choice_set_id, const smart_objects::SmartObject& choice_set) {
-  sync_primitives::AutoLock lock(choice_set_map_lock_);
+  sync_primitives::AutoLock lock(choice_set_map_lock_ptr_);
   ChoiceSetMap::const_iterator it = choice_set_map_.find(choice_set_id);
   if (choice_set_map_.end() == it) {
     choice_set_map_[choice_set_id] = new smart_objects::SmartObject(choice_set);
@@ -552,7 +555,7 @@ void DynamicApplicationDataImpl::AddChoiceSet(
 }
 
 void DynamicApplicationDataImpl::RemoveChoiceSet(uint32_t choice_set_id) {
-  sync_primitives::AutoLock lock(choice_set_map_lock_);
+  sync_primitives::AutoLock lock(choice_set_map_lock_ptr_);
   ChoiceSetMap::iterator it = choice_set_map_.find(choice_set_id);
 
   if (choice_set_map_.end() != it) {
@@ -563,7 +566,7 @@ void DynamicApplicationDataImpl::RemoveChoiceSet(uint32_t choice_set_id) {
 
 smart_objects::SmartObject* DynamicApplicationDataImpl::FindChoiceSet(
     uint32_t choice_set_id) {
-  sync_primitives::AutoLock lock(choice_set_map_lock_);
+  sync_primitives::AutoLock lock(choice_set_map_lock_ptr_);
   ChoiceSetMap::const_iterator it = choice_set_map_.find(choice_set_id);
   if (it != choice_set_map_.end()) {
     return it->second;
@@ -576,14 +579,14 @@ void DynamicApplicationDataImpl::AddPerformInteractionChoiceSet(
     uint32_t correlation_id,
     uint32_t choice_set_id,
     const smart_objects::SmartObject& vr_commands) {
-  sync_primitives::AutoLock lock(performinteraction_choice_set_lock_);
+  sync_primitives::AutoLock lock(performinteraction_choice_set_lock_ptr_);
   performinteraction_choice_set_map_[correlation_id].insert(std::make_pair(
       choice_set_id, new smart_objects::SmartObject(vr_commands)));
 }
 
 void DynamicApplicationDataImpl::DeletePerformInteractionChoiceSet(
     uint32_t correlation_id) {
-  sync_primitives::AutoLock lock(performinteraction_choice_set_lock_);
+  sync_primitives::AutoLock lock(performinteraction_choice_set_lock_ptr_);
   PerformChoice::iterator it =
       performinteraction_choice_set_map_[correlation_id].begin();
   for (; performinteraction_choice_set_map_[correlation_id].end() != it; ++it) {
diff --git a/src/components/application_manager/src/application_impl.cc b/src/components/application_manager/src/application_impl.cc
index ac21219d7d..068dc2027b 100644
--- a/src/components/application_manager/src/application_impl.cc
+++ b/src/components/application_manager/src/application_impl.cc
@@ -72,7 +72,7 @@ mobile_apis::FileType::eType StringToFileType(const char* str) {
     return mobile_apis::FileType::BINARY;
   }
 }
-}
+}  // namespace
 
 CREATE_LOGGERPTR_GLOBAL(logger_, "ApplicationManager")
 
@@ -139,6 +139,8 @@ ApplicationImpl::ApplicationImpl(
           "AudioStreamSuspend",
           new ::timer::TimerTaskImpl<ApplicationImpl>(
               this, &ApplicationImpl::OnAudioStreamSuspend))
+    , 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] = {
       date_time::DateTime::getCurrentTime(), 0};
@@ -712,13 +714,13 @@ const AppFile* ApplicationImpl::GetFile(const std::string& file_name) {
 
 bool ApplicationImpl::SubscribeToButton(
     mobile_apis::ButtonName::eType btn_name) {
-  sync_primitives::AutoLock lock(button_lock_);
+  sync_primitives::AutoLock lock(button_lock_ptr_);
   return subscribed_buttons_.insert(btn_name).second;
 }
 
 bool ApplicationImpl::IsSubscribedToButton(
     mobile_apis::ButtonName::eType btn_name) {
-  sync_primitives::AutoLock lock(button_lock_);
+  sync_primitives::AutoLock lock(button_lock_ptr_);
   std::set<mobile_apis::ButtonName::eType>::iterator it =
       subscribed_buttons_.find(btn_name);
   return (subscribed_buttons_.end() != it);
@@ -726,27 +728,27 @@ bool ApplicationImpl::IsSubscribedToButton(
 
 bool ApplicationImpl::UnsubscribeFromButton(
     mobile_apis::ButtonName::eType btn_name) {
-  sync_primitives::AutoLock lock(button_lock_);
+  sync_primitives::AutoLock lock(button_lock_ptr_);
   return subscribed_buttons_.erase(btn_name);
 }
 
 bool ApplicationImpl::SubscribeToIVI(uint32_t vehicle_info_type) {
-  sync_primitives::AutoLock lock(vi_lock_);
+  sync_primitives::AutoLock lock(vi_lock_ptr_);
   return subscribed_vehicle_info_
       .insert(
-           static_cast<mobile_apis::VehicleDataType::eType>(vehicle_info_type))
+          static_cast<mobile_apis::VehicleDataType::eType>(vehicle_info_type))
       .second;
 }
 
 bool ApplicationImpl::IsSubscribedToIVI(uint32_t vehicle_info_type) const {
-  sync_primitives::AutoLock lock(vi_lock_);
+  sync_primitives::AutoLock lock(vi_lock_ptr_);
   VehicleInfoSubscriptions::const_iterator it = subscribed_vehicle_info_.find(
       static_cast<mobile_apis::VehicleDataType::eType>(vehicle_info_type));
   return (subscribed_vehicle_info_.end() != it);
 }
 
 bool ApplicationImpl::UnsubscribeFromIVI(uint32_t vehicle_info_type) {
-  sync_primitives::AutoLock lock(vi_lock_);
+  sync_primitives::AutoLock lock(vi_lock_ptr_);
   return subscribed_vehicle_info_.erase(
       static_cast<mobile_apis::VehicleDataType::eType>(vehicle_info_type));
 }
@@ -857,12 +859,13 @@ bool ApplicationImpl::AreCommandLimitsExceeded(
 }
 
 DataAccessor<ButtonSubscriptions> ApplicationImpl::SubscribedButtons() const {
-  return DataAccessor<ButtonSubscriptions>(subscribed_buttons_, button_lock_);
+  return DataAccessor<ButtonSubscriptions>(subscribed_buttons_,
+                                           button_lock_ptr_);
 }
 
 DataAccessor<VehicleInfoSubscriptions> ApplicationImpl::SubscribedIVI() const {
   return DataAccessor<VehicleInfoSubscriptions>(subscribed_vehicle_info_,
-                                                vi_lock_);
+                                                vi_lock_ptr_);
 }
 
 const std::string& ApplicationImpl::curHash() const {
diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc
index 3ead8fe65e..0431aca41a 100644
--- a/src/components/application_manager/src/application_manager_impl.cc
+++ b/src/components/application_manager/src/application_manager_impl.cc
@@ -32,58 +32,58 @@
 
 #include <stdlib.h>  // for rand()
 
+#include <bson_object.h>
 #include <climits>
-#include <string>
 #include <fstream>
+#include <string>
 #include <utility>
-#include <bson_object.h>
 
+#include "application_manager/app_launch/app_launch_ctrl_impl.h"
+#include "application_manager/app_launch/app_launch_data_db.h"
+#include "application_manager/app_launch/app_launch_data_json.h"
 #include "application_manager/application_manager_impl.h"
-#include "application_manager/mobile_command_factory.h"
+#include "application_manager/command_holder_impl.h"
 #include "application_manager/commands/command_impl.h"
 #include "application_manager/commands/command_notification_impl.h"
+#include "application_manager/helpers/application_helper.h"
+#include "application_manager/hmi_capabilities_impl.h"
 #include "application_manager/message_helper.h"
+#include "application_manager/mobile_command_factory.h"
 #include "application_manager/mobile_message_handler.h"
 #include "application_manager/policies/policy_handler.h"
-#include "application_manager/hmi_capabilities_impl.h"
 #include "application_manager/resumption/resume_ctrl_impl.h"
-#include "application_manager/app_launch/app_launch_ctrl_impl.h"
-#include "application_manager/app_launch/app_launch_data_db.h"
-#include "application_manager/app_launch/app_launch_data_json.h"
-#include "application_manager/helpers/application_helper.h"
-#include "protocol_handler/protocol_handler.h"
-#include "hmi_message_handler/hmi_message_handler.h"
-#include "application_manager/command_holder_impl.h"
 #include "connection_handler/connection_handler_impl.h"
-#include "formatters/formatter_json_rpc.h"
-#include "formatters/CFormatterJsonSDLRPCv2.h"
 #include "formatters/CFormatterJsonSDLRPCv1.h"
+#include "formatters/CFormatterJsonSDLRPCv2.h"
+#include "formatters/formatter_json_rpc.h"
+#include "hmi_message_handler/hmi_message_handler.h"
 #include "protocol/bson_object_keys.h"
+#include "protocol_handler/protocol_handler.h"
 
-#include "utils/threads/thread.h"
-#include "utils/file_system.h"
-#include "utils/helpers.h"
-#include "utils/make_shared.h"
-#include "utils/timer_task_impl.h"
-#include "smart_objects/enum_schema_item.h"
-#include "interfaces/HMI_API_schema.h"
+#include <time.h>
 #include "application_manager/application_impl.h"
+#include "interfaces/HMI_API_schema.h"
 #include "media_manager/media_manager.h"
 #include "policy/usage_statistics/counter.h"
+#include "smart_objects/enum_schema_item.h"
 #include "utils/custom_string.h"
-#include <time.h>
+#include "utils/file_system.h"
+#include "utils/helpers.h"
+#include "utils/make_shared.h"
+#include "utils/threads/thread.h"
+#include "utils/timer_task_impl.h"
 
 #ifdef SDL_REMOTE_CONTROL
-#include "policy/usage_statistics/counter.h"
-#include "functional_module/plugin_manager.h"
 #include "application_manager/core_service.h"
+#include "functional_module/plugin_manager.h"
+#include "policy/usage_statistics/counter.h"
 #endif  // SDL_REMOTE_CONTROL
 
 namespace {
 int get_rand_from_range(uint32_t from = 0, int to = RAND_MAX) {
   return std::rand() % to + from;
 }
-}
+}  // namespace
 
 namespace application_manager {
 
@@ -141,7 +141,8 @@ ApplicationManagerImpl::ApplicationManagerImpl(
     const ApplicationManagerSettings& am_settings,
     const policy::PolicySettings& policy_settings)
     : settings_(am_settings)
-    , applications_list_lock_(true)
+    , applications_list_lock_ptr_(std::make_shared<sync_primitives::Lock>(true))
+    , apps_to_register_list_lock_ptr_(std::make_shared<sync_primitives::Lock>())
     , audio_pass_thru_active_(false)
     , audio_pass_thru_app_id_(0)
     , driver_distraction_state_(
@@ -230,7 +231,8 @@ ApplicationManagerImpl::~ApplicationManagerImpl() {
 }
 
 DataAccessor<ApplicationSet> ApplicationManagerImpl::applications() const {
-  DataAccessor<ApplicationSet> accessor(applications_, applications_list_lock_);
+  DataAccessor<ApplicationSet> accessor(applications_,
+                                        applications_list_lock_ptr_);
   return accessor;
 }
 
@@ -373,7 +375,7 @@ std::vector<ApplicationSharedPtr> ApplicationManagerImpl::IviInfoUpdated(
 void ApplicationManagerImpl::OnApplicationRegistered(ApplicationSharedPtr app) {
   LOG4CXX_AUTO_TRACE(logger_);
   DCHECK_OR_RETURN_VOID(app);
-  sync_primitives::AutoLock lock(applications_list_lock_);
+  sync_primitives::AutoLock lock(applications_list_lock_ptr_);
   const mobile_apis::HMILevel::eType default_level = GetDefaultHmiLevel(app);
   state_ctrl_.OnApplicationRegistered(app, default_level);
 
@@ -576,11 +578,13 @@ ApplicationSharedPtr ApplicationManagerImpl::RegisterApplication(
 
   Version version;
   int32_t min_version = message[strings::msg_params][strings::sync_msg_version]
-                               [strings::minor_version].asInt();
+                               [strings::minor_version]
+                                   .asInt();
   version.min_supported_api_version = static_cast<APIVersion>(min_version);
 
   int32_t max_version = message[strings::msg_params][strings::sync_msg_version]
-                               [strings::major_version].asInt();
+                               [strings::major_version]
+                                   .asInt();
   version.max_supported_api_version = static_cast<APIVersion>(max_version);
   application->set_version(version);
 
@@ -601,13 +605,13 @@ ApplicationSharedPtr ApplicationManagerImpl::RegisterApplication(
   }
 
   // Keep HMI add id in case app is present in "waiting for registration" list
-  apps_to_register_list_lock_.Acquire();
+  apps_to_register_list_lock_ptr_->Acquire();
   AppsWaitRegistrationSet::iterator it = apps_to_register_.find(application);
   if (apps_to_register_.end() != it) {
     application->set_hmi_application_id((*it)->hmi_app_id());
     apps_to_register_.erase(application);
   }
-  apps_to_register_list_lock_.Release();
+  apps_to_register_list_lock_ptr_->Release();
 
   if (!application->hmi_app_id()) {
     const bool is_saved =
@@ -640,11 +644,11 @@ ApplicationSharedPtr ApplicationManagerImpl::RegisterApplication(
   // Add application to registered app list and set appropriate mark.
   // Lock has to be released before adding app to policy DB to avoid possible
   // deadlock with simultaneous PTU processing
-  applications_list_lock_.Acquire();
+  applications_list_lock_ptr_->Acquire();
   application->MarkRegistered();
   applications_.insert(application);
   apps_size_ = applications_.size();
-  applications_list_lock_.Release();
+  applications_list_lock_ptr_->Release();
 
   return application;
 }
@@ -995,12 +999,12 @@ ApplicationConstSharedPtr ApplicationManagerImpl::WaitingApplicationByID(
 DataAccessor<AppsWaitRegistrationSet>
 ApplicationManagerImpl::AppsWaitingForRegistration() const {
   return DataAccessor<AppsWaitRegistrationSet>(apps_to_register_,
-                                               apps_to_register_list_lock_);
+                                               apps_to_register_list_lock_ptr_);
 }
 
 bool ApplicationManagerImpl::IsAppsQueriedFrom(
     const connection_handler::DeviceHandle handle) const {
-  sync_primitives::AutoLock lock(apps_to_register_list_lock_);
+  sync_primitives::AutoLock lock(apps_to_register_list_lock_ptr_);
   AppsWaitRegistrationSet::iterator it = apps_to_register_.begin();
   AppsWaitRegistrationSet::const_iterator it_end = apps_to_register_.end();
   for (; it != it_end; ++it) {
@@ -1021,7 +1025,7 @@ const ApplicationManagerSettings& ApplicationManagerImpl::get_settings() const {
 
 void application_manager::ApplicationManagerImpl::MarkAppsGreyOut(
     const connection_handler::DeviceHandle handle, bool is_greyed_out) {
-  sync_primitives::AutoLock lock(apps_to_register_list_lock_);
+  sync_primitives::AutoLock lock(apps_to_register_list_lock_ptr_);
   AppsWaitRegistrationSet::iterator it = apps_to_register_.begin();
   AppsWaitRegistrationSet::const_iterator it_end = apps_to_register_.end();
   for (; it != it_end; ++it) {
@@ -1191,7 +1195,7 @@ void ApplicationManagerImpl::SwitchApplication(ApplicationSharedPtr app,
                                                const std::string& mac_address) {
   LOG4CXX_AUTO_TRACE(logger_);
   DCHECK_OR_RETURN_VOID(app);
-  sync_primitives::AutoLock lock(applications_list_lock_);
+  sync_primitives::AutoLock lock(applications_list_lock_ptr_);
   DCHECK_OR_RETURN_VOID(1 == applications_.erase(app));
 
   LOG4CXX_DEBUG(logger_,
@@ -1514,9 +1518,9 @@ bool ApplicationManagerImpl::OnServiceStartedCallback(
   using namespace helpers;
   using namespace protocol_handler;
   LOG4CXX_AUTO_TRACE(logger_);
-  LOG4CXX_DEBUG(logger_,
-                "ServiceType = " << type << ". Session = " << std::hex
-                                 << session_key);
+  LOG4CXX_DEBUG(
+      logger_,
+      "ServiceType = " << type << ". Session = " << std::hex << session_key);
 
   if (type == kRpc) {
     LOG4CXX_DEBUG(logger_, "RPC service is about to be started.");
@@ -1524,9 +1528,9 @@ bool ApplicationManagerImpl::OnServiceStartedCallback(
   }
   ApplicationSharedPtr app = application(session_key);
   if (!app) {
-    LOG4CXX_WARN(logger_,
-                 "The application with id:" << session_key
-                                            << " doesn't exists.");
+    LOG4CXX_WARN(
+        logger_,
+        "The application with id:" << session_key << " doesn't exists.");
     return false;
   }
 
@@ -1552,9 +1556,9 @@ void ApplicationManagerImpl::OnServiceStartedCallback(
   using namespace helpers;
   using namespace protocol_handler;
   LOG4CXX_AUTO_TRACE(logger_);
-  LOG4CXX_DEBUG(logger_,
-                "ServiceType = " << type << ". Session = " << std::hex
-                                 << session_key);
+  LOG4CXX_DEBUG(
+      logger_,
+      "ServiceType = " << type << ". Session = " << std::hex << session_key);
   std::vector<std::string> empty;
 
   if (type == kRpc) {
@@ -1564,9 +1568,9 @@ void ApplicationManagerImpl::OnServiceStartedCallback(
   }
   ApplicationSharedPtr app = application(session_key);
   if (!app) {
-    LOG4CXX_WARN(logger_,
-                 "The application with id:" << session_key
-                                            << " doesn't exists.");
+    LOG4CXX_WARN(
+        logger_,
+        "The application with id:" << session_key << " doesn't exists.");
     connection_handler().NotifyServiceStartedResult(session_key, false, empty);
     return;
   }
@@ -2366,9 +2370,9 @@ bool ApplicationManagerImpl::ConvertMessageToSO(
       rpc::ValidationReport report("RPC");
 
       if (output.validate(&report) != smart_objects::Errors::OK) {
-        LOG4CXX_ERROR(logger_,
-                      "Incorrect parameter from HMI"
-                          << rpc::PrettyFormat(report));
+        LOG4CXX_ERROR(
+            logger_,
+            "Incorrect parameter from HMI" << rpc::PrettyFormat(report));
 
         output.erase(strings::msg_params);
         output[strings::params][hmi_response::code] =
@@ -2826,9 +2830,8 @@ void ApplicationManagerImpl::CreateApplications(SmartArray& obj_array,
 
     connection_handler::DeviceHandle device_id = 0;
 
-    if (-1 ==
-        connection_handler().get_session_observer().GetDataOnSessionKey(
-            connection_key, NULL, NULL, &device_id)) {
+    if (-1 == connection_handler().get_session_observer().GetDataOnSessionKey(
+                  connection_key, NULL, NULL, &device_id)) {
       LOG4CXX_ERROR(logger_,
                     "Failed to create application: no connection info.");
       continue;
@@ -2862,7 +2865,7 @@ void ApplicationManagerImpl::CreateApplications(SmartArray& obj_array,
     app->set_vr_synonyms(vrSynonym);
     app->set_tts_name(ttsName);
 
-    sync_primitives::AutoLock lock(apps_to_register_list_lock_);
+    sync_primitives::AutoLock lock(apps_to_register_list_lock_ptr_);
     LOG4CXX_DEBUG(
         logger_, "apps_to_register_ size before: " << apps_to_register_.size());
     apps_to_register_.insert(app);
@@ -3128,20 +3131,20 @@ void ApplicationManagerImpl::UnregisterAllApplications() {
 void ApplicationManagerImpl::RemoveAppsWaitingForRegistration(
     const connection_handler::DeviceHandle handle) {
   DevicePredicate device_finder(handle);
-  apps_to_register_list_lock_.Acquire();
+  apps_to_register_list_lock_ptr_->Acquire();
   AppsWaitRegistrationSet::iterator it_app = std::find_if(
       apps_to_register_.begin(), apps_to_register_.end(), device_finder);
 
   while (apps_to_register_.end() != it_app) {
-    LOG4CXX_DEBUG(logger_,
-                  "Waiting app: " << (*it_app)->name().c_str()
-                                  << " is removed.");
+    LOG4CXX_DEBUG(
+        logger_,
+        "Waiting app: " << (*it_app)->name().c_str() << " is removed.");
     apps_to_register_.erase(it_app);
     it_app = std::find_if(
         apps_to_register_.begin(), apps_to_register_.end(), device_finder);
   }
 
-  apps_to_register_list_lock_.Release();
+  apps_to_register_list_lock_ptr_->Release();
 }
 
 void ApplicationManagerImpl::UnregisterApplication(
@@ -3212,7 +3215,7 @@ void ApplicationManagerImpl::UnregisterApplication(
   ApplicationSharedPtr app_to_remove;
   connection_handler::DeviceHandle handle = 0;
   {
-    sync_primitives::AutoLock lock(applications_list_lock_);
+    sync_primitives::AutoLock lock(applications_list_lock_ptr_);
     auto it_app = applications_.begin();
     while (applications_.end() != it_app) {
       if (app_id == (*it_app)->app_id()) {
@@ -3659,21 +3662,21 @@ void ApplicationManagerImpl::ProcessPostponedMessages(const uint32_t app_id) {
   }
   MobileMessageQueue messages;
   app->SwapMobileMessageQueue(messages);
-  auto push_allowed_messages =
-      [this, &app](smart_objects::SmartObjectSPtr message) {
-        const std::string function_id = MessageHelper::StringifiedFunctionID(
-            static_cast<mobile_apis::FunctionID::eType>(
-                (*message)[strings::params][strings::function_id].asUInt()));
-        const RPCParams params;
-        const mobile_apis::Result::eType check_result =
-            CheckPolicyPermissions(app, function_id, params);
-        if (mobile_api::Result::SUCCESS == check_result) {
-          ManageMobileCommand(message,
-                              commands::Command::CommandOrigin::ORIGIN_SDL);
-        } else {
-          app->PushMobileMessage(message);
-        }
-      };
+  auto push_allowed_messages = [this,
+                                &app](smart_objects::SmartObjectSPtr message) {
+    const std::string function_id = MessageHelper::StringifiedFunctionID(
+        static_cast<mobile_apis::FunctionID::eType>(
+            (*message)[strings::params][strings::function_id].asUInt()));
+    const RPCParams params;
+    const mobile_apis::Result::eType check_result =
+        CheckPolicyPermissions(app, function_id, params);
+    if (mobile_api::Result::SUCCESS == check_result) {
+      ManageMobileCommand(message,
+                          commands::Command::CommandOrigin::ORIGIN_SDL);
+    } else {
+      app->PushMobileMessage(message);
+    }
+  };
   std::for_each(messages.begin(), messages.end(), push_allowed_messages);
 }
 
@@ -3976,9 +3979,9 @@ bool ApplicationManagerImpl::IsHMICooperating() const {
 void ApplicationManagerImpl::OnApplicationListUpdateTimer() {
   LOG4CXX_DEBUG(logger_, "Application list update timer finished");
 
-  apps_to_register_list_lock_.Acquire();
+  apps_to_register_list_lock_ptr_->Acquire();
   const bool trigger_ptu = apps_size_ != applications_.size();
-  apps_to_register_list_lock_.Release();
+  apps_to_register_list_lock_ptr_->Release();
   SendUpdateAppList();
   GetPolicyHandler().OnAppsSearchCompleted(trigger_ptu);
 }
@@ -4270,9 +4273,9 @@ bool ApplicationManagerImpl::InitDirectory(
     LOG4CXX_WARN(logger_, directory_type << " directory doesn't exist.");
     // if storage directory doesn't exist try to create it
     if (!file_system::CreateDirectoryRecursively(path)) {
-      LOG4CXX_ERROR(logger_,
-                    "Unable to create " << directory_type << " directory "
-                                        << path);
+      LOG4CXX_ERROR(
+          logger_,
+          "Unable to create " << directory_type << " directory " << path);
       return false;
     }
     LOG4CXX_DEBUG(logger_,
@@ -4287,9 +4290,9 @@ bool ApplicationManagerImpl::IsReadWriteAllowed(const std::string& path,
   const std::string directory_type = DirectoryTypeToString(type);
   if (!(file_system::IsWritingAllowed(path) &&
         file_system::IsReadingAllowed(path))) {
-    LOG4CXX_ERROR(logger_,
-                  directory_type
-                      << " directory doesn't have read/write permissions.");
+    LOG4CXX_ERROR(
+        logger_,
+        directory_type << " directory doesn't have read/write permissions.");
     return false;
   }
 
@@ -4465,10 +4468,10 @@ std::vector<std::string> ApplicationManagerImpl::ConvertRejectedParamList(
 
 #ifdef BUILD_TESTS
 void ApplicationManagerImpl::AddMockApplication(ApplicationSharedPtr mock_app) {
-  applications_list_lock_.Acquire();
+  applications_list_lock_ptr_->Acquire();
   applications_.insert(mock_app);
   apps_size_ = applications_.size();
-  applications_list_lock_.Release();
+  applications_list_lock_ptr_->Release();
 }
 
 void ApplicationManagerImpl::SetMockMediaManager(
diff --git a/src/components/application_manager/test/commands/command_request_impl_test.cc b/src/components/application_manager/test/commands/command_request_impl_test.cc
index 4493c54d3c..98489306d2 100644
--- a/src/components/application_manager/test/commands/command_request_impl_test.cc
+++ b/src/components/application_manager/test/commands/command_request_impl_test.cc
@@ -96,6 +96,9 @@ const std::string kMissedParam = "missed_param";
 class CommandRequestImplTest
     : public CommandRequestTest<CommandsTestMocks::kIsNice> {
  public:
+  CommandRequestImplTest()
+      : app_set_lock_ptr_(std::make_shared<sync_primitives::Lock>()) {}
+
   class UnwrappedCommandRequestImpl : public CommandRequestImpl {
    public:
     using CommandRequestImpl::CheckAllowedParameters;
@@ -133,11 +136,11 @@ class CommandRequestImplTest
     app_set->insert(app);
     EXPECT_CALL(app_mngr_, applications())
         .WillOnce(
-            Return(DataAccessor<ApplicationSet>(*app_set, app_set_lock_)));
+            Return(DataAccessor<ApplicationSet>(*app_set, app_set_lock_ptr_)));
     return app;
   }
 
-  sync_primitives::Lock app_set_lock_;
+  std::shared_ptr<sync_primitives::Lock> app_set_lock_ptr_;
 };
 
 typedef CommandRequestImplTest::UnwrappedCommandRequestImpl UCommandRequestImpl;
diff --git a/src/components/application_manager/test/commands/hmi/hmi_notifications/hmi_notifications_test.cc b/src/components/application_manager/test/commands/hmi/hmi_notifications/hmi_notifications_test.cc
index ffedf1b4f6..a5f7fa40d6 100644
--- a/src/components/application_manager/test/commands/hmi/hmi_notifications/hmi_notifications_test.cc
+++ b/src/components/application_manager/test/commands/hmi/hmi_notifications/hmi_notifications_test.cc
@@ -227,7 +227,9 @@ class HMICommandsNotificationsTest
           CommandsTestMocks::kIsNice> {
  public:
   HMICommandsNotificationsTest()
-      : applications_(application_set_, applications_lock_), app_ptr_(NULL) {}
+      : applications_lock_(std::make_shared<sync_primitives::Lock>())
+      , applications_(application_set_, applications_lock_)
+      , app_ptr_(NULL) {}
 
   ~HMICommandsNotificationsTest() {
     // Fix DataAccessor release and WinQt crash
@@ -237,7 +239,7 @@ class HMICommandsNotificationsTest
 
  protected:
   am::ApplicationSet application_set_;
-  sync_primitives::Lock applications_lock_;
+  std::shared_ptr<sync_primitives::Lock> applications_lock_;
   DataAccessor<am::ApplicationSet> applications_;
   MockHMICapabilities mock_hmi_capabilities_;
 
@@ -365,7 +367,8 @@ typedef Types<OnVIAccPedalPositionNotification,
               OnVITirePressureNotification,
               OnVIVehicleDataNotification,
               OnVIVinNotification,
-              OnVIWiperStatusNotification> HMIOnViNotificationsTypes;
+              OnVIWiperStatusNotification>
+    HMIOnViNotificationsTypes;
 
 typedef Types<OnAppPermissionChangedNotification,
               OnAudioDataStreamingNotification,
@@ -378,7 +381,8 @@ typedef Types<OnAppPermissionChangedNotification,
               OnSDLPersistenceCompleteNotification,
               OnStatusUpdateNotification,
               OnVideoDataStreamingNotification,
-              OnRecordStartdNotification> HMIOnNotificationsListToHMITypes;
+              OnRecordStartdNotification>
+    HMIOnNotificationsListToHMITypes;
 
 typedef Types<
     CommandPair<OnAppActivatedNotification,
@@ -1123,7 +1127,8 @@ TEST_F(HMICommandsNotificationsTest,
     EXPECT_CALL(app_mngr_, application(kAppId_)).WillRepeatedly(Return(app_));
     EXPECT_CALL(mock_message_helper_,
                 GetOnAppInterfaceUnregisteredNotificationToMobile(
-                    kAppId_, *it_mobile_reason)).WillOnce(Return(notification));
+                    kAppId_, *it_mobile_reason))
+        .WillOnce(Return(notification));
     EXPECT_CALL(app_mngr_,
                 ManageMobileCommand(notification, Command::ORIGIN_SDL));
     EXPECT_CALL(app_mngr_,
@@ -1485,10 +1490,11 @@ TEST_F(HMICommandsNotificationsTest,
             [am::strings::id] = "2014";
   utils::SharedPtr<Command> command =
       CreateCommand<OnDeviceChosenNotification>(message);
-  EXPECT_CALL(app_mngr_,
-              ConnectToDevice(
-                  (*message)[am::strings::msg_params][am::strings::device_info]
-                            [am::strings::id].asString()));
+  EXPECT_CALL(
+      app_mngr_,
+      ConnectToDevice((*message)[am::strings::msg_params]
+                                [am::strings::device_info][am::strings::id]
+                                    .asString()));
   command->Run();
 }
 
diff --git a/src/components/application_manager/test/commands/hmi/on_driver_distraction_notification_test.cc b/src/components/application_manager/test/commands/hmi/on_driver_distraction_notification_test.cc
index b8a8c68ece..f3ea7f22fe 100644
--- a/src/components/application_manager/test/commands/hmi/on_driver_distraction_notification_test.cc
+++ b/src/components/application_manager/test/commands/hmi/on_driver_distraction_notification_test.cc
@@ -33,19 +33,19 @@
 #include <stdint.h>
 #include <string>
 
-#include "gtest/gtest.h"
-#include "smart_objects/smart_object.h"
-#include "application_manager/smart_object_keys.h"
-#include "utils/shared_ptr.h"
-#include "utils/lock.h"
-#include "utils/make_shared.h"
-#include "utils/data_accessor.h"
-#include "commands/commands_test.h"
 #include "application_manager/mock_application.h"
 #include "application_manager/mock_application_manager.h"
 #include "application_manager/policies/mock_policy_handler_interface.h"
+#include "application_manager/smart_object_keys.h"
+#include "commands/commands_test.h"
+#include "gtest/gtest.h"
 #include "hmi/on_driver_distraction_notification.h"
 #include "interfaces/MOBILE_API.h"
+#include "smart_objects/smart_object.h"
+#include "utils/data_accessor.h"
+#include "utils/lock.h"
+#include "utils/make_shared.h"
+#include "utils/shared_ptr.h"
 
 namespace test {
 namespace components {
@@ -54,8 +54,8 @@ namespace hmi_commands_test {
 namespace on_driver_distraction_notification {
 
 using ::testing::_;
-using ::testing::Return;
 using ::testing::Eq;
+using ::testing::Return;
 using ::utils::SharedPtr;
 
 namespace am = ::application_manager;
@@ -68,7 +68,10 @@ typedef ::utils::SharedPtr<OnDriverDistractionNotification> NotificationPtr;
 class HMIOnDriverDistractionNotificationTest
     : public CommandsTest<CommandsTestMocks::kIsNice> {
  public:
-  ::sync_primitives::Lock app_set_lock_;
+  HMIOnDriverDistractionNotificationTest()
+      : app_set_lock_ptr_(std::make_shared<sync_primitives::Lock>()) {}
+  std::shared_ptr<sync_primitives::Lock> app_set_lock_ptr_;
+
   policy_test::MockPolicyHandlerInterface mock_policy_handler_interface_;
 };
 
@@ -104,7 +107,7 @@ TEST_F(HMIOnDriverDistractionNotificationTest, Run_PushMobileMessage_SUCCESS) {
   am::ApplicationSet app_set;
   app_set.insert(mock_app);
 
-  DataAccessor<am::ApplicationSet> accessor(app_set, app_set_lock_);
+  DataAccessor<am::ApplicationSet> accessor(app_set, app_set_lock_ptr_);
   EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(accessor));
   policy::CheckPermissionResult result;
   result.hmi_level_permitted = policy::kRpcDisallowed;
@@ -136,7 +139,7 @@ TEST_F(HMIOnDriverDistractionNotificationTest,
   am::ApplicationSet app_set;
   app_set.insert(mock_app);
 
-  DataAccessor<am::ApplicationSet> accessor(app_set, app_set_lock_);
+  DataAccessor<am::ApplicationSet> accessor(app_set, app_set_lock_ptr_);
   EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(accessor));
 
   policy::CheckPermissionResult result;
@@ -154,7 +157,7 @@ TEST_F(HMIOnDriverDistractionNotificationTest,
   command->Run();
 }
 
-}  // on_driver_distraction_notification
+}  // namespace on_driver_distraction_notification
 }  // namespace hmi_commands_test
 }  // namespace commands_test
 }  // namespace components
diff --git a/src/components/application_manager/test/commands/hmi/sdl_activate_app_request_test.cc b/src/components/application_manager/test/commands/hmi/sdl_activate_app_request_test.cc
index d36b55ee25..7fe2a85a21 100644
--- a/src/components/application_manager/test/commands/hmi/sdl_activate_app_request_test.cc
+++ b/src/components/application_manager/test/commands/hmi/sdl_activate_app_request_test.cc
@@ -100,6 +100,10 @@ MATCHER_P2(CheckMsgParams, result, corr_id, "") {
 
 class SDLActivateAppRequestTest
     : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  SDLActivateAppRequestTest()
+      : lock_(std::make_shared<sync_primitives::Lock>()) {}
+
  protected:
   ~SDLActivateAppRequestTest() {
     // Fix DataAccessor release and WinQt crash
@@ -119,7 +123,7 @@ class SDLActivateAppRequestTest
   }
 
   ApplicationSet app_list_;
-  ::sync_primitives::Lock lock_;
+  std::shared_ptr<sync_primitives::Lock> lock_;
   policy_test::MockPolicyHandlerInterface policy_handler_;
   application_manager_test::MockStateController mock_state_controller_;
   NiceMock<event_engine_test::MockEventDispatcher> mock_event_dispatcher_;
diff --git a/src/components/application_manager/test/commands/mobile/add_command_request_test.cc b/src/components/application_manager/test/commands/mobile/add_command_request_test.cc
index 471f0763de..1ae15ec1a1 100644
--- a/src/components/application_manager/test/commands/mobile/add_command_request_test.cc
+++ b/src/components/application_manager/test/commands/mobile/add_command_request_test.cc
@@ -103,6 +103,7 @@ class AddCommandRequestTest
   AddCommandRequestTest()
       : msg_(CreateMessage())
       , default_app_name_("test_default_app_name_")
+      , lock_ptr_(std::make_shared<sync_primitives::Lock>())
       , mock_app_(CreateMockApp()) {
     EXPECT_CALL(app_mngr_, application(kConnectionKey))
         .WillRepeatedly(Return(mock_app_));
@@ -176,7 +177,7 @@ class AddCommandRequestTest
         CreateCommandsMap(first_command, second_command);
     EXPECT_CALL(*mock_app_, commands_map())
         .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
-            commands_map, lock_)));
+            commands_map, lock_ptr_)));
     so_ptr_ = utils::MakeShared<SmartObject>(SmartType_Map);
     EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId))
         .WillOnce(Return(so_ptr_.get()));
@@ -219,7 +220,7 @@ class AddCommandRequestTest
   MessageSharedPtr msg_;
   SmartObjectSPtr so_ptr_;
   const utils::custom_string::CustomString default_app_name_;
-  sync_primitives::Lock lock_;
+  std::shared_ptr<sync_primitives::Lock> lock_ptr_;
   MockAppPtr mock_app_;
 };
 
@@ -262,8 +263,8 @@ TEST_F(AddCommandRequestTest, Run_MenuNameHasSyntaxError_EXPECT_INVALID_DATA) {
   EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get()));
   am::CommandsMap commands_map;
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   SmartObject parent = SmartObject(SmartType_Map);
   EXPECT_CALL(*mock_app_, FindSubMenu(kFirstParentId))
       .WillOnce(Return(&parent));
@@ -283,8 +284,8 @@ TEST_F(AddCommandRequestTest,
   EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get()));
   am::CommandsMap commands_map;
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   EXPECT_CALL(app_mngr_,
               ManageMobileCommand(
                   MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _));
@@ -308,8 +309,8 @@ TEST_F(AddCommandRequestTest, Run_CMDIconHasError_EXPECT_INVALID_DATA) {
   EXPECT_CALL(*mock_app_, FindCommand(kCmdId)).WillOnce(Return(so_ptr_.get()));
   am::CommandsMap commands_map;
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   EXPECT_CALL(app_mngr_,
               ManageMobileCommand(
                   MobileResultCodeIs(mobile_apis::Result::INVALID_DATA), _));
@@ -348,8 +349,8 @@ TEST_F(AddCommandRequestTest,
   const am::CommandsMap commands_map =
       CreateCommandsMap(first_command, second_command);
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   EXPECT_CALL(app_mngr_,
               ManageMobileCommand(
                   MobileResultCodeIs(mobile_apis::Result::DUPLICATE_NAME), _));
@@ -372,8 +373,8 @@ TEST_F(AddCommandRequestTest,
   const am::CommandsMap commands_map =
       CreateCommandsMap(first_command, second_command);
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId))
       .WillOnce(Return(so_ptr_.get()));
   EXPECT_CALL(app_mngr_,
@@ -400,8 +401,8 @@ TEST_F(AddCommandRequestTest,
   const am::CommandsMap commands_map =
       CreateCommandsMap(first_command, second_command);
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   so_ptr_ = utils::MakeShared<SmartObject>(SmartType_Map);
   EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId))
       .WillOnce(Return(so_ptr_.get()));
@@ -443,8 +444,8 @@ TEST_F(AddCommandRequestTest,
   const am::CommandsMap commands_map =
       CreateCommandsMap(first_command, second_command);
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   so_ptr_ = utils::MakeShared<SmartObject>(SmartType_Map);
   EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId))
       .WillOnce(Return(so_ptr_.get()));
@@ -475,8 +476,8 @@ TEST_F(AddCommandRequestTest, GetRunMethods_SUCCESS) {
 
   am::CommandsMap commands_map;
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   EXPECT_CALL(
       app_mngr_,
       ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
@@ -497,7 +498,7 @@ TEST_F(AddCommandRequestTest, OnEvent_UI_SUCCESS) {
   am::CommandsMap commands_map;
   EXPECT_CALL(*mock_app_, commands_map())
       .WillRepeatedly(
-          Return(DataAccessor<am::CommandsMap>(commands_map, lock_)));
+          Return(DataAccessor<am::CommandsMap>(commands_map, lock_ptr_)));
 
   Event event(hmi_apis::FunctionID::UI_AddCommand);
   event.set_smart_object(*msg_);
@@ -524,7 +525,7 @@ TEST_F(AddCommandRequestTest, OnEvent_VR_SUCCESS) {
   am::CommandsMap commands_map;
   EXPECT_CALL(*mock_app_, commands_map())
       .WillRepeatedly(
-          Return(DataAccessor<am::CommandsMap>(commands_map, lock_)));
+          Return(DataAccessor<am::CommandsMap>(commands_map, lock_ptr_)));
   EXPECT_CALL(
       app_mngr_,
       ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand)))
@@ -596,8 +597,8 @@ TEST_F(AddCommandRequestTest,
       .WillOnce(Return(mobile_apis::Result::SUCCESS));
   am::CommandsMap commands_map;
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   EXPECT_CALL(
       app_mngr_,
       ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
@@ -625,8 +626,8 @@ TEST_F(AddCommandRequestTest,
       .WillOnce(Return(mobile_apis::Result::SUCCESS));
   am::CommandsMap commands_map;
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   {
     InSequence dummy;
     EXPECT_CALL(
@@ -664,8 +665,8 @@ TEST_F(
       .WillOnce(Return(mobile_apis::Result::SUCCESS));
   am::CommandsMap commands_map;
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   {
     InSequence dummy;
     EXPECT_CALL(
@@ -708,8 +709,8 @@ TEST_F(
       .WillOnce(Return(mobile_apis::Result::SUCCESS));
   am::CommandsMap commands_map;
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   {
     InSequence dummy;
     EXPECT_CALL(
@@ -752,8 +753,8 @@ TEST_F(
       .WillOnce(Return(mobile_apis::Result::SUCCESS));
   am::CommandsMap commands_map;
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   {
     InSequence dummy;
     EXPECT_CALL(
@@ -801,8 +802,8 @@ TEST_F(
       .WillOnce(Return(mobile_apis::Result::SUCCESS));
   am::CommandsMap commands_map;
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   {
     InSequence dummy;
     EXPECT_CALL(
@@ -849,8 +850,8 @@ TEST_F(
       .WillOnce(Return(mobile_apis::Result::SUCCESS));
   am::CommandsMap commands_map;
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   EXPECT_CALL(
       app_mngr_,
       ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::UI_AddCommand)))
@@ -884,8 +885,8 @@ TEST_F(
   params[hmi_response::code] = hmi_apis::Common_Result::UNSUPPORTED_RESOURCE;
   am::CommandsMap commands_map;
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   EXPECT_CALL(
       app_mngr_,
       ManageHMICommand(HMIResultCodeIs(hmi_apis::FunctionID::VR_AddCommand)))
@@ -922,8 +923,8 @@ TEST_F(AddCommandRequestTest,
       .WillOnce(Return(mobile_apis::Result::SUCCESS));
   am::CommandsMap commands_map;
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   {
     InSequence dummy;
     EXPECT_CALL(
@@ -970,8 +971,8 @@ TEST_F(AddCommandRequestTest,
       .WillOnce(Return(mobile_apis::Result::SUCCESS));
   am::CommandsMap commands_map;
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   {
     InSequence dummy;
     EXPECT_CALL(
@@ -1042,8 +1043,8 @@ TEST_F(AddCommandRequestTest, OnTimeOut_AppRemoveCommandCalled) {
   const am::CommandsMap commands_map =
       CreateCommandsMap(first_command, second_command);
   EXPECT_CALL(*mock_app_, commands_map())
-      .WillRepeatedly(Return(
-          DataAccessor<application_manager::CommandsMap>(commands_map, lock_)));
+      .WillRepeatedly(Return(DataAccessor<application_manager::CommandsMap>(
+          commands_map, lock_ptr_)));
   so_ptr_ = utils::MakeShared<SmartObject>(SmartType_Map);
   EXPECT_CALL(*mock_app_, FindSubMenu(kSecondParentId))
       .WillOnce(Return(so_ptr_.get()));
@@ -1077,8 +1078,8 @@ TEST_F(AddCommandRequestTest, OnTimeOut_AppRemoveCommandCalled) {
   base_class_request->onTimeOut();
 }
 
-}  // namespace add_command_test
+}  // namespace add_command_request
 }  // namespace mobile_commands_test
 }  // namespace commands_test
 }  // namespace components
-}  // namespace tests
+}  // namespace test
diff --git a/src/components/application_manager/test/commands/mobile/change_registration_test.cc b/src/components/application_manager/test/commands/mobile/change_registration_test.cc
index 3d7671015c..e20e89cb9b 100644
--- a/src/components/application_manager/test/commands/mobile/change_registration_test.cc
+++ b/src/components/application_manager/test/commands/mobile/change_registration_test.cc
@@ -88,7 +88,8 @@ class ChangeRegistrationRequestTest
     : public CommandRequestTest<CommandsTestMocks::kIsNice> {
  public:
   ChangeRegistrationRequestTest()
-      : mock_app_(CreateMockApp())
+      : app_set_lock_ptr_(std::make_shared<sync_primitives::Lock>())
+      , mock_app_(CreateMockApp())
       , supported_languages_(CreateMessage(smart_objects::SmartType_Array)) {}
 
   MessageSharedPtr CreateMsgFromMobile() {
@@ -160,7 +161,8 @@ class ChangeRegistrationRequestTest
     MockAppPtr app = CreateMockApp();
     app->set_name(name);
 
-    DataAccessor<am::ApplicationSet> accessor(application_set, app_set_lock_);
+    DataAccessor<am::ApplicationSet> accessor(application_set,
+                                              app_set_lock_ptr_);
 
     application_set.insert(app);
 
@@ -269,7 +271,7 @@ class ChangeRegistrationRequestTest
                  NiceMock<application_manager_test::MockHMICapabilities>,
                  application_manager_test::MockHMICapabilities>::Result
       MockHMICapabilities;
-  sync_primitives::Lock app_set_lock_;
+  std::shared_ptr<sync_primitives::Lock> app_set_lock_ptr_;
   MockHMICapabilities hmi_capabilities_;
   MockAppPtr mock_app_;
   MessageSharedPtr supported_languages_;
@@ -289,7 +291,7 @@ TEST_F(ChangeRegistrationRequestTest,
   MockAppPtr app = CreateMockApp();
   app->set_name(name);
 
-  DataAccessor<am::ApplicationSet> accessor(application_set, app_set_lock_);
+  DataAccessor<am::ApplicationSet> accessor(application_set, app_set_lock_ptr_);
 
   application_set.insert(app);
 
@@ -378,7 +380,7 @@ TEST_F(ChangeRegistrationRequestTest,
   const utils::custom_string::CustomString name("name");
   MockAppPtr app = CreateMockApp();
   app->set_name(name);
-  DataAccessor<am::ApplicationSet> accessor(application_set, app_set_lock_);
+  DataAccessor<am::ApplicationSet> accessor(application_set, app_set_lock_ptr_);
   application_set.insert(app);
   EXPECT_CALL(app_mngr_, applications()).WillOnce(Return(accessor));
   EXPECT_CALL(*app, name()).WillOnce(ReturnRef(name));
@@ -483,7 +485,7 @@ TEST_F(ChangeRegistrationRequestTest,
   MockAppPtr app = CreateMockApp();
   app->set_name(name);
 
-  DataAccessor<am::ApplicationSet> accessor(application_set, app_set_lock_);
+  DataAccessor<am::ApplicationSet> accessor(application_set, app_set_lock_ptr_);
 
   application_set.insert(app);
 
@@ -562,4 +564,4 @@ TEST_F(ChangeRegistrationRequestTest,
 }  // namespace mobile_commands_test
 }  // namespace commands_test
 }  // namespace components
-}  // namespace tests
+}  // namespace test
diff --git a/src/components/application_manager/test/commands/mobile/create_interaction_choice_set_test.cc b/src/components/application_manager/test/commands/mobile/create_interaction_choice_set_test.cc
index c3513d2acb..8412fc85f0 100644
--- a/src/components/application_manager/test/commands/mobile/create_interaction_choice_set_test.cc
+++ b/src/components/application_manager/test/commands/mobile/create_interaction_choice_set_test.cc
@@ -113,7 +113,7 @@ class CreateInteractionChoiceSetRequestTest
   CreateInteractionChoiceSetRequestTest()
       : message_(CreateMessage())
       , command_(CreateCommand<CreateInteractionChoiceSetRequest>(message_))
-      , mock_app_(CreateMockApp()) {}
+      , mock_app_(CreateMockApp()), lock_(std::make_shared<sync_primitives::Lock>()) {}
 
   MessageSharedPtr CreateFullParamsVRSO() {
     MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
@@ -158,7 +158,7 @@ class CreateInteractionChoiceSetRequestTest
   MessageSharedPtr message_;
   CreateInteractionChoiceSetRequestPtr command_;
   MockAppPtr mock_app_;
-  sync_primitives::Lock lock_;
+  std::shared_ptr<sync_primitives::Lock> lock_;
 };
 
 class CreateInteractionChoiceSetResponseTest
diff --git a/src/components/application_manager/test/commands/mobile/delete_interaction_choice_set_test.cc b/src/components/application_manager/test/commands/mobile/delete_interaction_choice_set_test.cc
index 192cad12b0..508b615a62 100644
--- a/src/components/application_manager/test/commands/mobile/delete_interaction_choice_set_test.cc
+++ b/src/components/application_manager/test/commands/mobile/delete_interaction_choice_set_test.cc
@@ -84,7 +84,9 @@ class DeleteInteractionChoiceSetRequestTest
     : public CommandRequestTest<CommandsTestMocks::kIsNice> {
  public:
   DeleteInteractionChoiceSetRequestTest()
-      : accessor_(choice_set_map_, performinteraction_choice_set_lock_) {}
+      : performinteraction_choice_set_lock_(
+            std::make_shared<sync_primitives::Lock>())
+      , accessor_(choice_set_map_, performinteraction_choice_set_lock_) {}
 
   ~DeleteInteractionChoiceSetRequestTest() {
     // Fix DataAccessor release and WinQt crash
@@ -92,7 +94,8 @@ class DeleteInteractionChoiceSetRequestTest
   }
 
   am::PerformChoiceSetMap choice_set_map_;
-  mutable sync_primitives::Lock performinteraction_choice_set_lock_;
+  mutable std::shared_ptr<sync_primitives::Lock>
+      performinteraction_choice_set_lock_;
   DataAccessor<am::PerformChoiceSetMap> accessor_;
 
  protected:
diff --git a/src/components/application_manager/test/commands/mobile/delete_sub_menu_test.cc b/src/components/application_manager/test/commands/mobile/delete_sub_menu_test.cc
index cc21e5366e..6a55537cf1 100644
--- a/src/components/application_manager/test/commands/mobile/delete_sub_menu_test.cc
+++ b/src/components/application_manager/test/commands/mobile/delete_sub_menu_test.cc
@@ -95,13 +95,14 @@ class DeleteSubMenuRequestTest
     : public CommandRequestTest<CommandsTestMocks::kIsNice> {
  public:
   DeleteSubMenuRequestTest()
-      : accessor_(commands_map_, commands_lock_)
+      : commands_lock_(std::make_shared<sync_primitives::Lock>())
+      , accessor_(commands_map_, commands_lock_)
       , message_(CreateMessage())
       , command_(CreateCommand<DeleteSubMenuRequest>(message_))
       , app_(CreateMockApp()) {}
 
   am::CommandsMap commands_map_;
-  mutable sync_primitives::Lock commands_lock_;
+  mutable std::shared_ptr<sync_primitives::Lock> commands_lock_;
   DataAccessor<am::CommandsMap> accessor_;
 
   MessageSharedPtr message_;
@@ -143,8 +144,8 @@ TEST_F(DeleteSubMenuRequestTest, DISABLED_OnEvent_UI_UNSUPPORTED_RESOURCE) {
   am::CommandsMap commands_map;
   smart_objects::SmartObject commands_msg(smart_objects::SmartType_Map);
   commands_map.insert(std::pair<uint32_t, SmartObject*>(1u, &commands_msg));
-  sync_primitives::Lock lock;
-  DataAccessor<am::CommandsMap> accessor(commands_map, lock);
+  DataAccessor<am::CommandsMap> accessor(
+      commands_map, std::make_shared<sync_primitives::Lock>());
   EXPECT_CALL(*mock_app, commands_map())
       .WillOnce(Return(accessor))
       .WillOnce(Return(accessor));
diff --git a/src/components/application_manager/test/commands/mobile/on_hmi_status_notification_from_mobile_test.cc b/src/components/application_manager/test/commands/mobile/on_hmi_status_notification_from_mobile_test.cc
index 78875ad164..6f158c0abf 100644
--- a/src/components/application_manager/test/commands/mobile/on_hmi_status_notification_from_mobile_test.cc
+++ b/src/components/application_manager/test/commands/mobile/on_hmi_status_notification_from_mobile_test.cc
@@ -61,6 +61,8 @@ using testing::_;
 class OnHMIStatusNotificationFromMobileTest
     : public CommandsTest<CommandsTestMocks::kIsNice> {
  public:
+  OnHMIStatusNotificationFromMobileTest()
+      : lock_(std::make_shared<sync_primitives::Lock>()) {}
   MessageSharedPtr CreateMsgParams(
       const mobile_apis::HMILevel::eType kHMIState) {
     MessageSharedPtr msg = CreateMessage();
@@ -69,7 +71,7 @@ class OnHMIStatusNotificationFromMobileTest
     return msg;
   }
   ApplicationSet app_set_;
-  sync_primitives::Lock lock_;
+  std::shared_ptr<sync_primitives::Lock> lock_;
 };
 
 TEST_F(OnHMIStatusNotificationFromMobileTest,
diff --git a/src/components/application_manager/test/commands/mobile/on_keyboard_input_notification_test.cc b/src/components/application_manager/test/commands/mobile/on_keyboard_input_notification_test.cc
index 7313f32dca..9ea7beaa28 100644
--- a/src/components/application_manager/test/commands/mobile/on_keyboard_input_notification_test.cc
+++ b/src/components/application_manager/test/commands/mobile/on_keyboard_input_notification_test.cc
@@ -61,6 +61,8 @@ using testing::_;
 class OnKeyBoardInputNotificationTest
     : public CommandsTest<CommandsTestMocks::kIsNice> {
  public:
+  OnKeyBoardInputNotificationTest()
+      : lock_(std::make_shared<sync_primitives::Lock>()) {}
   void SetSendNotificationExpectations(MessageSharedPtr msg) {
     EXPECT_CALL(mock_message_helper_, PrintSmartObject(_))
         .WillOnce(Return(false));
@@ -86,7 +88,7 @@ class OnKeyBoardInputNotificationTest
   }
 
   SharedPtr<ApplicationSet> app_set_;
-  sync_primitives::Lock lock_;
+  std::shared_ptr<sync_primitives::Lock> lock_;
 };
 
 TEST_F(OnKeyBoardInputNotificationTest, Run_ActionActive_SUCCESS) {
diff --git a/src/components/application_manager/test/commands/mobile/register_app_interface_request_test.cc b/src/components/application_manager/test/commands/mobile/register_app_interface_request_test.cc
index 2e3e5fbfdf..173cb28b0b 100644
--- a/src/components/application_manager/test/commands/mobile/register_app_interface_request_test.cc
+++ b/src/components/application_manager/test/commands/mobile/register_app_interface_request_test.cc
@@ -93,6 +93,7 @@ class RegisterAppInterfaceRequestTest
       : msg_(CreateMessage())
       , command_(CreateCommand<RegisterAppInterfaceRequest>(msg_))
       , app_name_("test_app_name_")
+      ,lock_ptr_(std::make_shared<sync_primitives::Lock>())
       , mock_application_helper_(
             application_manager_test::MockApplicationHelper::
                 application_helper_mock()) {
@@ -231,7 +232,7 @@ class RegisterAppInterfaceRequestTest
   SharedPtr<RegisterAppInterfaceRequest> command_;
 
   const utils::custom_string::CustomString app_name_;
-  sync_primitives::Lock lock_;
+  std::shared_ptr<sync_primitives::Lock> lock_ptr_;
   am::ApplicationSet app_set_;
 
   typedef IsNiceMock<policy_test::MockPolicyHandlerInterface,
@@ -278,7 +279,7 @@ TEST_F(RegisterAppInterfaceRequestTest, Run_MinimalData_SUCCESS) {
       .WillRepeatedly(Return(mock_app));
 
   ON_CALL(app_mngr_, applications())
-      .WillByDefault(Return(DataAccessor<am::ApplicationSet>(app_set_, lock_)));
+      .WillByDefault(Return(DataAccessor<am::ApplicationSet>(app_set_, lock_ptr_)));
   ON_CALL(mock_policy_handler_, PolicyEnabled()).WillByDefault(Return(true));
   ON_CALL(mock_policy_handler_, GetInitialAppData(kAppId, _, _))
       .WillByDefault(Return(true));
@@ -353,7 +354,7 @@ TEST_F(RegisterAppInterfaceRequestTest,
   display_capabilities[am::hmi_response::text_fields] = "test_text_fields";
   display_capabilities[am::hmi_response::image_fields] = "test_image_fields";
   display_capabilities[am::hmi_response::media_clock_formats] =
-      "test_media_clock_formats";
+      "test_media_clock_ptr_formats";
   display_capabilities[am::hmi_response::num_custom_presets_available] =
       "test_num_custom_presets_available";
   display_capabilities[am::hmi_response::graphic_supported] =
@@ -373,7 +374,7 @@ TEST_F(RegisterAppInterfaceRequestTest,
           Return(&(*expected_message)[am::hmi_response::display_capabilities]));
 
   ON_CALL(app_mngr_, applications())
-      .WillByDefault(Return(DataAccessor<am::ApplicationSet>(app_set_, lock_)));
+      .WillByDefault(Return(DataAccessor<am::ApplicationSet>(app_set_, lock_ptr_)));
   ON_CALL(mock_policy_handler_, PolicyEnabled()).WillByDefault(Return(true));
   ON_CALL(mock_policy_handler_, GetInitialAppData(kAppId, _, _))
       .WillByDefault(Return(true));
diff --git a/src/components/application_manager/test/commands/mobile/set_global_properties_test.cc b/src/components/application_manager/test/commands/mobile/set_global_properties_test.cc
index 641e5636a9..60c1d102f2 100644
--- a/src/components/application_manager/test/commands/mobile/set_global_properties_test.cc
+++ b/src/components/application_manager/test/commands/mobile/set_global_properties_test.cc
@@ -74,7 +74,9 @@ const uint32_t kPosition = 1u;
 class SetGlobalPropertiesRequestTest
     : public CommandRequestTest<CommandsTestMocks::kIsNice> {
  public:
-  SetGlobalPropertiesRequestTest() : mock_app_(CreateMockApp()) {}
+  SetGlobalPropertiesRequestTest()
+      : lock_ptr_(std::make_shared<sync_primitives::Lock>())
+      , mock_app_(CreateMockApp()) {}
 
   MessageSharedPtr CreateFullParamsUISO() {
     MessageSharedPtr msg = CreateMessage(smart_objects::SmartType_Map);
@@ -244,7 +246,7 @@ class SetGlobalPropertiesRequestTest
             GetInterfaceState(am::HmiInterfaces::HMI_INTERFACE_TTS))
         .WillByDefault(Return(am::HmiInterfaces::STATE_AVAILABLE));
   }
-  sync_primitives::Lock lock_;
+  std::shared_ptr<sync_primitives::Lock> lock_ptr_;
   MockAppPtr mock_app_;
 };
 
@@ -606,7 +608,7 @@ TEST_F(SetGlobalPropertiesRequestTest, Run_VRCouldNotGenerate_INVALID_DATA) {
   CommandsMap commands_map;
   SmartObject empty_msg(smart_objects::SmartType_Map);
   commands_map.insert(std::pair<uint32_t, SmartObject*>(1u, &empty_msg));
-  DataAccessor<CommandsMap> accessor(commands_map, lock_);
+  DataAccessor<CommandsMap> accessor(commands_map, lock_ptr_);
   EXPECT_CALL(*mock_app_, commands_map()).WillOnce(Return(accessor));
   EXPECT_CALL(*mock_app_, vr_help_title()).WillOnce(Return(vr_help_title));
   EXPECT_CALL(*mock_app_, set_menu_title(_)).Times(0);
@@ -638,7 +640,7 @@ TEST_F(SetGlobalPropertiesRequestTest, Run_NoVRNoDataNoDefault_Canceled) {
       .WillOnce(Return(&vr_help_title));
 
   CommandsMap commands_map;
-  DataAccessor<CommandsMap> accessor(commands_map, lock_);
+  DataAccessor<CommandsMap> accessor(commands_map, lock_ptr_);
   EXPECT_CALL(*mock_app_, commands_map()).WillOnce(Return(accessor));
   const CustomString name("name");
   EXPECT_CALL(*mock_app_, name()).WillOnce(ReturnRef(name));
@@ -681,7 +683,7 @@ TEST_F(SetGlobalPropertiesRequestTest, Run_NoVRNoDataDefaultCreated_SUCCESS) {
   SmartObject command_text(smart_objects::SmartType_Map);
   commands_map[0] = &command_text;
   (*commands_map[0])[am::strings::vr_commands] = SmartObject("one");
-  DataAccessor<CommandsMap> accessor(commands_map, lock_);
+  DataAccessor<CommandsMap> accessor(commands_map, lock_ptr_);
   EXPECT_CALL(*mock_app_, commands_map()).WillOnce(Return(accessor));
   EXPECT_CALL(*mock_app_, set_vr_help(_));
   const CustomString name("name");
@@ -723,7 +725,7 @@ TEST_F(SetGlobalPropertiesRequestTest, Run_NoVRNoDataFromSynonyms_SUCCESS) {
       .WillRepeatedly(Return(&vr_help_title));
 
   CommandsMap commands_map;
-  DataAccessor<CommandsMap> accessor(commands_map, lock_);
+  DataAccessor<CommandsMap> accessor(commands_map, lock_ptr_);
   EXPECT_CALL(*mock_app_, commands_map()).WillOnce(Return(accessor));
   SmartObject vr_help_array(smart_objects::SmartType_Array);
   vr_help_array[0] = SmartObject(smart_objects::SmartType_Map);
@@ -1226,4 +1228,4 @@ TEST_F(SetGlobalPropertiesRequestTest,
 }  // namespace mobile_commands_test
 }  // namespace commands_test
 }  // namespace components
-}  // namespace tests
+}  // namespace test
diff --git a/src/components/application_manager/test/commands/mobile/unsubscribe_vehicle_request_test.cc b/src/components/application_manager/test/commands/mobile/unsubscribe_vehicle_request_test.cc
index bb4824e8f7..d6bc72b1d8 100644
--- a/src/components/application_manager/test/commands/mobile/unsubscribe_vehicle_request_test.cc
+++ b/src/components/application_manager/test/commands/mobile/unsubscribe_vehicle_request_test.cc
@@ -51,8 +51,8 @@ namespace mobile_result = mobile_apis::Result;
 
 using ::testing::_;
 
-using am::commands::UnsubscribeVehicleDataRequest;
 using am::commands::MessageSharedPtr;
+using am::commands::UnsubscribeVehicleDataRequest;
 
 typedef ::utils::SharedPtr<UnsubscribeVehicleDataRequest> CommandPtr;
 
@@ -65,9 +65,13 @@ const mobile_apis::VehicleDataType::eType kVehicleType =
 
 class UnsubscribeVehicleRequestTest
     : public CommandRequestTest<CommandsTestMocks::kIsNice> {
+ public:
+  UnsubscribeVehicleRequestTest()
+      : app_set_lock_ptr_(std::make_shared<sync_primitives::Lock>()) {}
+
  protected:
   void UnsubscribeSuccessfully();
-  sync_primitives::Lock app_set_lock_;
+  std::shared_ptr<sync_primitives::Lock> app_set_lock_ptr_;
 };
 
 TEST_F(UnsubscribeVehicleRequestTest, Run_AppNotRegistered_UNSUCCESS) {
@@ -191,7 +195,8 @@ void UnsubscribeVehicleRequestTest::UnsubscribeSuccessfully() {
   am::ApplicationSet application_set_;
   MockAppPtr mock_app(CreateMockApp());
   application_set_.insert(mock_app);
-  DataAccessor<am::ApplicationSet> accessor(application_set_, app_set_lock_);
+  DataAccessor<am::ApplicationSet> accessor(application_set_,
+                                            app_set_lock_ptr_);
 
   EXPECT_CALL(app_mngr_, application(kConnectionKey))
       .WillRepeatedly(Return(mock_app));
diff --git a/src/components/application_manager/test/hmi_language_handler_test.cc b/src/components/application_manager/test/hmi_language_handler_test.cc
index 2020da5052..3ad1b7f7e4 100644
--- a/src/components/application_manager/test/hmi_language_handler_test.cc
+++ b/src/components/application_manager/test/hmi_language_handler_test.cc
@@ -82,7 +82,8 @@ const uint32_t kDefaultAppsSize = 0u;
 
 class HmiLanguageHandlerTest : public ::testing::Test {
  public:
-  HmiLanguageHandlerTest() {
+  HmiLanguageHandlerTest()
+      : app_set_lock_(std::make_shared<sync_primitives::Lock>()) {
     EXPECT_CALL(app_manager_, event_dispatcher())
         .WillOnce(ReturnRef(event_dispatcher_));
     hmi_language_handler_ =
@@ -133,7 +134,7 @@ class HmiLanguageHandlerTest : public ::testing::Test {
   MockHMICapabilities hmi_capabilities_;
   MockEventDispatcher event_dispatcher_;
   SharedPtr<am::HMILanguageHandler> hmi_language_handler_;
-  ::sync_primitives::Lock app_set_lock_;
+  std::shared_ptr<sync_primitives::Lock> app_set_lock_;
   resumption_test::MockLastState last_state_;
 };
 
diff --git a/src/components/application_manager/test/include/application_manager/commands/commands_test.h b/src/components/application_manager/test/include/application_manager/commands/commands_test.h
index 553126091f..8dce6f7375 100644
--- a/src/components/application_manager/test/include/application_manager/commands/commands_test.h
+++ b/src/components/application_manager/test/include/application_manager/commands/commands_test.h
@@ -137,6 +137,7 @@ class CommandsTest : public ::testing::Test {
 
   enum { kDefaultTimeout_ = 100 };
 
+
   MockAppManager app_mngr_;
   MockAppManagerSettings app_mngr_settings_;
   MOCK(am::MockHmiInterfaces) mock_hmi_interfaces_;
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 436c8c165e..fbc9b90aec 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
@@ -33,19 +33,19 @@
 #ifndef SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_RESUMPTION_DATA_TEST_H_
 #define SRC_COMPONENTS_APPLICATION_MANAGER_TEST_INCLUDE_APPLICATION_MANAGER_RESUMPTION_DATA_TEST_H_
 
-#include <string>
 #include <algorithm>
-#include "gtest/gtest.h"
-#include "application_manager/usage_statistics.h"
+#include <string>
+#include "application_manager/event_engine/event_dispatcher.h"
 #include "application_manager/mock_application.h"
 #include "application_manager/mock_application_manager.h"
-#include "utils/data_accessor.h"
-#include "config_profile/profile.h"
+#include "application_manager/mock_application_manager_settings.h"
 #include "application_manager/policies/policy_handler.h"
-#include "application_manager/state_controller.h"
 #include "application_manager/resumption/resume_ctrl.h"
-#include "application_manager/event_engine/event_dispatcher.h"
-#include "application_manager/mock_application_manager_settings.h"
+#include "application_manager/state_controller.h"
+#include "application_manager/usage_statistics.h"
+#include "config_profile/profile.h"
+#include "gtest/gtest.h"
+#include "utils/data_accessor.h"
 
 namespace test {
 namespace components {
@@ -68,7 +68,13 @@ class ResumptionDataTest : public ::testing::Test {
       , kCountOfSubmenues_(3u)
       , kCountOfFiles_(8u)
       , kCountOfVrhelptitle_(2u)
-      , kMacAddress_("12345") {}
+      , kMacAddress_("12345")
+
+      , sublock_ptr_(std::make_shared<sync_primitives::Lock>())
+      , comlock_ptr_(std::make_shared<sync_primitives::Lock>())
+      , setlock_ptr_(std::make_shared<sync_primitives::Lock>())
+      , btnlock_ptr_(std::make_shared<sync_primitives::Lock>())
+      , ivilock_ptr_(std::make_shared<sync_primitives::Lock>()) {}
   // Check structure in saved application
   void CheckSavedApp(sm::SmartObject& saved_data);
   // Set data for resumption
@@ -139,11 +145,11 @@ class ResumptionDataTest : public ::testing::Test {
   am::ButtonSubscriptions btn_subscr;
   am::VehicleInfoSubscriptions ivi;
 
-  sync_primitives::Lock sublock_;
-  sync_primitives::Lock comlock_;
-  sync_primitives::Lock setlock_;
-  sync_primitives::Lock btnlock_;
-  sync_primitives::Lock ivilock_;
+  std::shared_ptr<sync_primitives::Lock> sublock_ptr_;
+  std::shared_ptr<sync_primitives::Lock> comlock_ptr_;
+  std::shared_ptr<sync_primitives::Lock> setlock_ptr_;
+  std::shared_ptr<sync_primitives::Lock> btnlock_ptr_;
+  std::shared_ptr<sync_primitives::Lock> ivilock_ptr_;
   application_manager_test::MockApplicationManagerSettings
       mock_application_manager_settings_;
   application_manager_test::MockApplicationManager mock_application_manager_;
diff --git a/src/components/application_manager/test/message_helper/message_helper_test.cc b/src/components/application_manager/test/message_helper/message_helper_test.cc
index 289e4f5d05..951cd3ccb6 100644
--- a/src/components/application_manager/test/message_helper/message_helper_test.cc
+++ b/src/components/application_manager/test/message_helper/message_helper_test.cc
@@ -39,6 +39,7 @@
 #include "application_manager/policies/policy_handler.h"
 #include "application_manager/mock_application.h"
 #include "utils/custom_string.h"
+#include "utils/lock.h"
 #include "policy/mock_policy_settings.h"
 #include "application_manager/policies/policy_handler.h"
 #include "application_manager/mock_application_manager.h"
@@ -236,7 +237,7 @@ TEST(MessageHelperTestCreate,
      CreateAddCommandRequestToHMI_SendSmartObject_Empty) {
   MockApplicationSharedPtr appSharedMock = utils::MakeShared<MockApplication>();
   ::application_manager::CommandsMap vis;
-  DataAccessor<application_manager::CommandsMap> data_accessor(vis, true);
+  DataAccessor<application_manager::CommandsMap> data_accessor(vis, std::make_shared<sync_primitives::Lock>(true));
 
   EXPECT_CALL(*appSharedMock, commands_map()).WillOnce(Return(data_accessor));
   application_manager_test::MockApplicationManager mock_application_manager;
@@ -251,7 +252,7 @@ TEST(MessageHelperTestCreate,
      CreateAddCommandRequestToHMI_SendSmartObject_Equal) {
   MockApplicationSharedPtr appSharedMock = utils::MakeShared<MockApplication>();
   CommandsMap vis;
-  DataAccessor<CommandsMap> data_accessor(vis, true);
+  DataAccessor<CommandsMap> data_accessor(vis, std::make_shared<sync_primitives::Lock>(true));
   smart_objects::SmartObjectSPtr smartObjectPtr =
       utils::MakeShared<smart_objects::SmartObject>();
 
@@ -292,7 +293,7 @@ TEST(MessageHelperTestCreate,
      CreateAddVRCommandRequestFromChoiceToHMI_SendEmptyData_EmptyList) {
   MockApplicationSharedPtr appSharedMock = utils::MakeShared<MockApplication>();
   application_manager::ChoiceSetMap vis;
-  DataAccessor< ::application_manager::ChoiceSetMap> data_accessor(vis, true);
+  DataAccessor< ::application_manager::ChoiceSetMap> data_accessor(vis, std::make_shared<sync_primitives::Lock>(true));
 
   EXPECT_CALL(*appSharedMock, choice_set_map()).WillOnce(Return(data_accessor));
   application_manager_test::MockApplicationManager mock_application_manager;
@@ -307,7 +308,7 @@ TEST(MessageHelperTestCreate,
      CreateAddVRCommandRequestFromChoiceToHMI_SendObject_EqualList) {
   MockApplicationSharedPtr appSharedMock = utils::MakeShared<MockApplication>();
   application_manager::ChoiceSetMap vis;
-  DataAccessor< ::application_manager::ChoiceSetMap> data_accessor(vis, true);
+  DataAccessor< ::application_manager::ChoiceSetMap> data_accessor(vis, std::make_shared<sync_primitives::Lock>(true));
   smart_objects::SmartObjectSPtr smartObjectPtr =
       utils::MakeShared<smart_objects::SmartObject>();
 
@@ -353,7 +354,7 @@ TEST(MessageHelperTestCreate,
 TEST(MessageHelperTestCreate, CreateAddSubMenuRequestToHMI_SendObject_Equal) {
   MockApplicationSharedPtr appSharedMock = utils::MakeShared<MockApplication>();
   application_manager::SubMenuMap vis;
-  DataAccessor< ::application_manager::SubMenuMap> data_accessor(vis, true);
+  DataAccessor< ::application_manager::SubMenuMap> data_accessor(vis, std::make_shared<sync_primitives::Lock>(true));
   smart_objects::SmartObjectSPtr smartObjectPtr =
       utils::MakeShared<smart_objects::SmartObject>();
 
@@ -392,7 +393,7 @@ TEST(MessageHelperTestCreate,
      CreateAddSubMenuRequestToHMI_SendEmptyMap_EmptySmartObjectList) {
   MockApplicationSharedPtr appSharedMock = utils::MakeShared<MockApplication>();
   application_manager::SubMenuMap vis;
-  DataAccessor< ::application_manager::SubMenuMap> data_accessor(vis, true);
+  DataAccessor< ::application_manager::SubMenuMap> data_accessor(vis, std::make_shared<sync_primitives::Lock>(true));
 
   EXPECT_CALL(*appSharedMock, sub_menu_map()).WillOnce(Return(data_accessor));
 
@@ -713,7 +714,7 @@ TEST_F(MessageHelperTest,
   // Creating data acessor
   application_manager::VehicleInfoSubscriptions vis;
   DataAccessor<application_manager::VehicleInfoSubscriptions> data_accessor(
-      vis, true);
+      vis, std::make_shared<sync_primitives::Lock>(true));
   // Calls for ApplicationManager
   EXPECT_CALL(*appSharedMock, app_id()).WillOnce(Return(1u));
   EXPECT_CALL(*appSharedMock, SubscribedIVI()).WillOnce(Return(data_accessor));
diff --git a/src/components/application_manager/test/policy_handler_test.cc b/src/components/application_manager/test/policy_handler_test.cc
index 3cd34bfaaa..991f1f218d 100644
--- a/src/components/application_manager/test/policy_handler_test.cc
+++ b/src/components/application_manager/test/policy_handler_test.cc
@@ -30,47 +30,45 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <fstream>
 #include <string>
 #include <vector>
-#include <fstream>
 #include "gmock/gmock.h"
 
-#include "application_manager/policies/policy_handler.h"
+#include "application_manager/application_impl.h"
+#include "application_manager/application_manager_impl.h"
 #include "application_manager/policies/delegates/app_permission_delegate.h"
+#include "application_manager/policies/policy_handler.h"
 #include "connection_handler/connection_handler_impl.h"
-#include "application_manager/application_manager_impl.h"
-#include "application_manager/application_impl.h"
 #ifdef ENABLE_SECURITY
-#include "security_manager/mock_security_manager.h"
 #include "security_manager/mock_crypto_manager.h"
+#include "security_manager/mock_security_manager.h"
 #endif  // ENABLE_SECURITY
+#include "application_manager/mock_application.h"
+#include "application_manager/mock_application_manager.h"
+#include "application_manager/mock_event_dispatcher.h"
+#include "application_manager/mock_hmi_capabilities.h"
 #include "application_manager/mock_message_helper.h"
+#include "application_manager/mock_state_controller.h"
+#include "application_manager/policies/mock_policy_handler_observer.h"
+#include "connection_handler/mock_connection_handler.h"
 #include "connection_handler/mock_connection_handler_settings.h"
-#include "transport_manager/mock_transport_manager.h"
-#include "policy/policy_types.h"
+#include "interfaces/MOBILE_API.h"
 #include "json/reader.h"
-#include "json/writer.h"
 #include "json/value.h"
-#include "smart_objects/smart_object.h"
-#include "utils/file_system.h"
-#include "utils/make_shared.h"
-#include "utils/custom_string.h"
-#include "policy/usage_statistics/counter.h"
-#include "policy/usage_statistics/statistics_manager.h"
-#include "interfaces/MOBILE_API.h"
+#include "json/writer.h"
+#include "policy/mock_policy_manager.h"
 #include "policy/mock_policy_settings.h"
-#include "utils/make_shared.h"
-#include "application_manager/mock_application.h"
+#include "policy/policy_types.h"
+#include "policy/usage_statistics/counter.h"
 #include "policy/usage_statistics/mock_statistics_manager.h"
+#include "policy/usage_statistics/statistics_manager.h"
 #include "protocol_handler/mock_session_observer.h"
-#include "connection_handler/mock_connection_handler.h"
-#include "application_manager/mock_application_manager.h"
-#include "application_manager/policies/mock_policy_handler_observer.h"
-#include "application_manager/mock_event_dispatcher.h"
-#include "application_manager/mock_state_controller.h"
-#include "application_manager/mock_hmi_capabilities.h"
-#include "policy/mock_policy_manager.h"
-#include "policy/usage_statistics/mock_statistics_manager.h"
+#include "smart_objects/smart_object.h"
+#include "transport_manager/mock_transport_manager.h"
+#include "utils/custom_string.h"
+#include "utils/file_system.h"
+#include "utils/make_shared.h"
 
 namespace test {
 namespace components {
@@ -80,15 +78,13 @@ using namespace application_manager;
 using namespace policy;
 using namespace utils::custom_string;
 using testing::_;
+using ::testing::DoAll;
 using ::testing::Mock;
+using ::testing::NiceMock;
 using ::testing::Return;
 using ::testing::ReturnRef;
-using ::testing::NiceMock;
-using ::testing::SetArgReferee;
 using ::testing::SetArgPointee;
-using ::testing::DoAll;
 using ::testing::SetArgReferee;
-using ::testing::Mock;
 
 const std::string kDummyData = "some_data";
 
@@ -105,7 +101,8 @@ class PolicyHandlerTest : public ::testing::Test {
       , default_hmi_("fake_hmi")
       , kPreloadPTFile_("sdl_preloaded_pt.json")
       , kAppStorageFolder_("storage")
-      , app_set(test_app, app_lock)
+      , app_lock_ptr_(std::make_shared<sync_primitives::Lock>())
+      , app_set(test_app, app_lock_ptr_)
       , kAppId1_(10u)
       , kAppId2_(11u)
       , kConnectionKey_(1u)
@@ -149,7 +146,7 @@ class PolicyHandlerTest : public ::testing::Test {
   const std::string kPreloadPTFile_;
   const std::string kAppStorageFolder_;
   ApplicationSet test_app;
-  sync_primitives::Lock app_lock;
+  std::shared_ptr<sync_primitives::Lock> app_lock_ptr_;
   DataAccessor<ApplicationSet> app_set;
   const uint32_t kAppId1_;
   const uint32_t kAppId2_;
@@ -297,7 +294,7 @@ class WaitAsync {
   const uint32_t timeout_;
   sync_primitives::ConditionalVariable cond_var_;
 };
-}
+}  // namespace
 
 TEST_F(PolicyHandlerTest, LoadPolicyLibrary_Method_ExpectLibraryLoaded) {
   // Check before policy enabled from ini file
@@ -443,7 +440,8 @@ TEST_F(PolicyHandlerTest, OnPermissionsUpdated_TwoParams_InvalidApp_UNSUCCESS) {
   EXPECT_CALL(app_manager_, application_by_policy_id(kPolicyAppId_))
       .WillOnce(Return(invalid_app));
   EXPECT_CALL(mock_message_helper_,
-              SendOnPermissionsChangeNotification(_, _, _)).Times(0);
+              SendOnPermissionsChangeNotification(_, _, _))
+      .Times(0);
 
   Permissions permissions;
   policy_handler_.OnPermissionsUpdated(kPolicyAppId_, permissions);
@@ -911,12 +909,14 @@ TEST_F(PolicyHandlerTest,
   AppPermissions permissions(kPolicyAppId_);
   permissions.appPermissionsConsentNeeded = false;
   EXPECT_CALL(mock_message_helper_,
-              SendOnAppPermissionsChangedNotification(kAppId1_, _, _)).Times(0);
+              SendOnAppPermissionsChangedNotification(kAppId1_, _, _))
+      .Times(0);
 
   EXPECT_CALL(*mock_policy_manager_, GetAppPermissionsChanges(_))
       .WillOnce(Return(permissions));
   EXPECT_CALL(*mock_policy_manager_,
-              RemovePendingPermissionChanges(kPolicyAppId_)).Times(0);
+              RemovePendingPermissionChanges(kPolicyAppId_))
+      .Times(0);
   // Act
   policy_handler_.OnPendingPermissionChange(kPolicyAppId_);
 }
@@ -1047,7 +1047,8 @@ TEST_F(PolicyHandlerTest,
   // Check expectations
   // Notification won't be sent
   EXPECT_CALL(mock_message_helper_,
-              SendOnAppPermissionsChangedNotification(kAppId1_, _, _)).Times(0);
+              SendOnAppPermissionsChangedNotification(kAppId1_, _, _))
+      .Times(0);
 
   EXPECT_CALL(*mock_policy_manager_, GetAppPermissionsChanges(_))
       .WillOnce(Return(permissions));
@@ -2170,7 +2171,8 @@ TEST_F(PolicyHandlerTest,
                   _,
                   NULL,
                   _,
-                  _)).WillOnce(Return(1u));
+                  _))
+      .WillOnce(Return(1u));
 
   EXPECT_CALL(app_manager_, application(kConnectionKey_))
       .WillOnce(Return(mock_app_));
diff --git a/src/components/application_manager/test/rc_policy_handler_test.cc b/src/components/application_manager/test/rc_policy_handler_test.cc
index 7faf3e36cb..0d9cbfe6aa 100644
--- a/src/components/application_manager/test/rc_policy_handler_test.cc
+++ b/src/components/application_manager/test/rc_policy_handler_test.cc
@@ -67,11 +67,11 @@ using namespace application_manager;
 using namespace policy;
 using namespace utils::custom_string;
 using testing::_;
+using ::testing::DoAll;
 using ::testing::Mock;
+using ::testing::NiceMock;
 using ::testing::Return;
 using ::testing::ReturnRef;
-using ::testing::NiceMock;
-using ::testing::DoAll;
 using ::testing::SetArgPointee;
 
 class RCPolicyHandlerTest : public ::testing::Test {
@@ -83,7 +83,8 @@ class RCPolicyHandlerTest : public ::testing::Test {
       , kDeviceId_("fake_device_id")
       , kHmiLevel_("NONE")
       , default_hmi_("fake_hmi")
-      , app_set(test_app, app_lock)
+      , app_lock_ptr_(std::make_shared<sync_primitives::Lock>())
+      , app_set(test_app, app_lock_ptr_)
       , kAppId1_(10u)
       , kAppId2_(11u)
       , kConnectionKey_(1u)
@@ -107,7 +108,7 @@ class RCPolicyHandlerTest : public ::testing::Test {
   const std::string kHmiLevel_;
   std::string default_hmi_;
   ApplicationSet test_app;
-  sync_primitives::Lock app_lock;
+  std::shared_ptr<sync_primitives::Lock> app_lock_ptr_;
   DataAccessor<ApplicationSet> app_set;
   const uint32_t kAppId1_;
   const uint32_t kAppId2_;
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 85801d7e73..da7f050f3f 100644
--- a/src/components/application_manager/test/resumption/resume_ctrl_test.cc
+++ b/src/components/application_manager/test/resumption/resume_ctrl_test.cc
@@ -55,14 +55,14 @@ namespace resumption_test {
 
 using ::testing::_;
 using ::testing::A;
-using ::testing::Return;
-using ::testing::ReturnRef;
+using ::testing::AtLeast;
 using ::testing::DoAll;
-using ::testing::SetArgReferee;
+using ::testing::Eq;
 using ::testing::Mock;
 using ::testing::NiceMock;
-using ::testing::AtLeast;
-using ::testing::Eq;
+using ::testing::Return;
+using ::testing::ReturnRef;
+using ::testing::SetArgReferee;
 using namespace application_manager_test;
 
 using namespace resumption;
@@ -80,7 +80,8 @@ class ResumeCtrlTest : public ::testing::Test {
       , kTestGrammarId_(10)
       , kHash_("saved_hash")
       , kAppResumingTimeout_(30000u)  // miliseconds
-      , kTestTimeStamp_(1452074434u) {}
+      , kTestTimeStamp_(1452074434u)
+      , app_set_lock_ptr_(std::make_shared<sync_primitives::Lock>()) {}
 
   virtual void SetUp() OVERRIDE {
     Mock::VerifyAndClearExpectations(&app_mngr_);
@@ -136,7 +137,7 @@ class ResumeCtrlTest : public ::testing::Test {
   const std::string kHash_;
   const uint32_t kAppResumingTimeout_;
   const uint32_t kTestTimeStamp_;
-  sync_primitives::Lock app_set_lock_;
+  std::shared_ptr<sync_primitives::Lock> app_set_lock_ptr_;
 };
 
 /**
@@ -442,7 +443,8 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithSubscribeOnButtons) {
   EXPECT_CALL(*app_mock_, UpdateHash());
 
   EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(),
-              SendAllOnButtonSubscriptionNotificationsForApp(_, _)).Times(2);
+              SendAllOnButtonSubscriptionNotificationsForApp(_, _))
+      .Times(2);
 
   const bool res = res_ctrl_->StartResumption(app_mock_, kHash_);
   EXPECT_TRUE(res);
@@ -487,7 +489,8 @@ TEST_F(ResumeCtrlTest, StartResumption_AppWithSubscriptionToIVI) {
 
   smart_objects::SmartObjectList requests;
   EXPECT_CALL(*application_manager::MockMessageHelper::message_helper_mock(),
-              GetIVISubscriptionRequests(_)).WillRepeatedly(Return(requests));
+              GetIVISubscriptionRequests(_))
+      .WillRepeatedly(Return(requests));
 
   EXPECT_CALL(*app_mock_, UpdateHash());
   const bool res = res_ctrl_->StartResumption(app_mock_, kHash_);
@@ -648,7 +651,7 @@ TEST_F(ResumeCtrlTest, ApplicationResumptiOnTimer_AppInFull) {
 
 /**
  * @brief group of tests which check correct SetAppHMIState
-*/
+ */
 
 TEST_F(ResumeCtrlTest, SetAppHMIState_HMINone_WithoutCheckPolicy) {
   GetInfoFromApp();
@@ -730,7 +733,7 @@ TEST_F(ResumeCtrlTest, SaveAllApplications) {
   app_set.insert(test_app);
 
   DataAccessor<application_manager::ApplicationSet> accessor(app_set,
-                                                             app_set_lock_);
+                                                             app_set_lock_ptr_);
 
   ON_CALL(app_mngr_, applications()).WillByDefault(Return(accessor));
   EXPECT_CALL(*mock_storage_, SaveApplication(Eq(test_app)));
@@ -744,7 +747,7 @@ TEST_F(ResumeCtrlTest, SaveAllApplications_EmptyApplicationlist) {
   application_manager::ApplicationSet app_set;
 
   DataAccessor<application_manager::ApplicationSet> accessor(app_set,
-                                                             app_set_lock_);
+                                                             app_set_lock_ptr_);
 
   ON_CALL(app_mngr_, applications()).WillByDefault(Return(accessor));
   EXPECT_CALL(*mock_storage_, SaveApplication(mock_app)).Times(0);
@@ -894,7 +897,7 @@ TEST_F(ResumeCtrlTest, OnSuspend_EmptyApplicationlist) {
   application_manager::ApplicationSet app_set;
 
   DataAccessor<application_manager::ApplicationSet> accessor(app_set,
-                                                             app_set_lock_);
+                                                             app_set_lock_ptr_);
 
   ON_CALL(app_mngr_, applications()).WillByDefault(Return(accessor));
   EXPECT_CALL(*mock_storage_, SaveApplication(mock_app)).Times(0);
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 0f90fe978f..a160f08daa 100644
--- a/src/components/application_manager/test/resumption/resumption_data_test.cc
+++ b/src/components/application_manager/test/resumption/resumption_data_test.cc
@@ -328,13 +328,13 @@ void ResumptionDataTest::PrepareData() {
   SetChoiceSet();
   SetAppFiles();
 
-  DataAccessor<am::SubMenuMap> sub_menu_m(test_submenu_map, sublock_);
-  DataAccessor<am::CommandsMap> commands_m(test_commands_map, comlock_);
-  DataAccessor<am::ChoiceSetMap> choice_set_m(test_choiceset_map, setlock_);
+  DataAccessor<am::SubMenuMap> sub_menu_m(test_submenu_map, sublock_ptr_);
+  DataAccessor<am::CommandsMap> commands_m(test_commands_map, comlock_ptr_);
+  DataAccessor<am::ChoiceSetMap> choice_set_m(test_choiceset_map, setlock_ptr_);
 
   SetSubscriptions();
-  DataAccessor<am::ButtonSubscriptions> btn_sub(btn_subscr, btnlock_);
-  DataAccessor<am::VehicleInfoSubscriptions> ivi_access(ivi, ivilock_);
+  DataAccessor<am::ButtonSubscriptions> btn_sub(btn_subscr, btnlock_ptr_);
+  DataAccessor<am::VehicleInfoSubscriptions> ivi_access(ivi, ivilock_ptr_);
 
   ON_CALL(*app_mock, is_application_data_changed()).WillByDefault(Return(true));
 
diff --git a/src/components/application_manager/test/state_controller/state_controller_test.cc b/src/components/application_manager/test/state_controller/state_controller_test.cc
index fe4d1d2ee8..c31597367c 100644
--- a/src/components/application_manager/test/state_controller/state_controller_test.cc
+++ b/src/components/application_manager/test/state_controller/state_controller_test.cc
@@ -60,14 +60,14 @@ using am::HmiState;
 using am::HmiStatePtr;
 using am::UsageStatistics;
 using ::testing::_;
-using ::testing::Return;
-using ::testing::ReturnRef;
-using ::testing::ReturnPointee;
+using ::testing::AtLeast;
+using ::testing::InSequence;
 using ::testing::Mock;
 using ::testing::NiceMock;
-using ::testing::InSequence;
+using ::testing::Return;
+using ::testing::ReturnPointee;
+using ::testing::ReturnRef;
 using ::testing::Truly;
-using ::testing::AtLeast;
 
 namespace test {
 namespace components {
@@ -76,7 +76,7 @@ namespace state_controller_test {
 namespace constants {
 const uint32_t kCorrID = 314u;
 const uint32_t kHMIAppID = 2718u;
-}
+}  // namespace constants
 
 struct HmiStatesComparator {
   mobile_apis::HMILevel::eType hmi_level_;
@@ -134,7 +134,8 @@ class StateControllerImplTest : public ::testing::Test {
       , usage_stat("0",
                    utils::SharedPtr<usage_statistics::StatisticsManager>(
                        new usage_statistics_test::MockStatisticsManager))
-      , applications_(application_set_, applications_lock_)
+      , applications_lock_ptr_(std::make_shared<sync_primitives::Lock>())
+      , applications_(application_set_, applications_lock_ptr_)
       , message_helper_mock_(
             *application_manager::MockMessageHelper::message_helper_mock()) {
     Mock::VerifyAndClearExpectations(&message_helper_mock_);
@@ -154,7 +155,7 @@ class StateControllerImplTest : public ::testing::Test {
   NiceMock<event_engine_test::MockEventDispatcher> mock_event_dispatcher_;
 
   am::ApplicationSet application_set_;
-  mutable sync_primitives::Lock applications_lock_;
+  mutable std::shared_ptr<sync_primitives::Lock> applications_lock_ptr_;
   DataAccessor<am::ApplicationSet> applications_;
   utils::SharedPtr<am::StateControllerImpl> state_ctrl_;
 
@@ -984,8 +985,8 @@ class StateControllerImplTest : public ::testing::Test {
   void ApplyTempStatesForApplication(
       NiceMock<application_manager_test::MockApplication>& application,
       std::vector<am::HmiState::StateID>& state_ids) {
-    using smart_objects::SmartObject;
     using am::event_engine::Event;
+    using smart_objects::SmartObject;
     namespace FunctionID = hmi_apis::FunctionID;
 
     EXPECT_CALL(application, CurrentHmiState())
@@ -1042,8 +1043,8 @@ class StateControllerImplTest : public ::testing::Test {
   void CheckStateApplyingForApplication(
       NiceMock<application_manager_test::MockApplication>& application,
       std::vector<am::HmiState::StateID>& state_ids) {
-    using smart_objects::SmartObject;
     using am::event_engine::Event;
+    using smart_objects::SmartObject;
     namespace FunctionID = hmi_apis::FunctionID;
 
     EXPECT_CALL(application, CurrentHmiState())
@@ -1052,7 +1053,8 @@ class StateControllerImplTest : public ::testing::Test {
     for (uint32_t i = 0; i < state_ids.size(); ++i) {
       am::HmiState::StateID state_id = state_ids[i];
       EXPECT_CALL(application,
-                  AddHMIState(Truly(HmiStatesIDComparator(state_id)))).Times(1);
+                  AddHMIState(Truly(HmiStatesIDComparator(state_id))))
+          .Times(1);
 
       switch (state_id) {
         case am::HmiState::StateID::STATE_ID_VR_SESSION: {
@@ -1905,7 +1907,8 @@ TEST_F(StateControllerImplTest, SendEventBCActivateApp_HMIReceivesError) {
     EXPECT_CALL(app_manager_mock_, SendHMIStatusNotification(simple_app_))
         .Times(0);
     EXPECT_CALL(app_manager_mock_,
-                OnHMILevelChanged(simple_app_->app_id(), _, _)).Times(0);
+                OnHMILevelChanged(simple_app_->app_id(), _, _))
+        .Times(0);
 
     smart_objects::SmartObject message;
     message[am::strings::params][am::hmi_response::code] = *it;
@@ -2459,7 +2462,8 @@ TEST_F(StateControllerImplTest, SetRegularStateMediaToNonMediaApp_VR_Stopped) {
   EXPECT_CALL(*simple_app_ptr_, is_resuming()).WillRepeatedly(Return(false));
 
   EXPECT_CALL(message_helper_mock_,
-              SendOnResumeAudioSourceToHMI(simple_app_id_, _)).Times(0);
+              SendOnResumeAudioSourceToHMI(simple_app_id_, _))
+      .Times(0);
   EXPECT_CALL(*simple_app_ptr_,
               SetPostponedState(Truly(HmiStatesComparator(check_state))))
       .Times(0);
diff --git a/src/components/include/utils/data_accessor.h b/src/components/include/utils/data_accessor.h
index 9be28a638b..24b3106a4c 100644
--- a/src/components/include/utils/data_accessor.h
+++ b/src/components/include/utils/data_accessor.h
@@ -32,6 +32,7 @@
 #ifndef SRC_COMPONENTS_INCLUDE_UTILS_DATA_ACCESSOR_H_
 #define SRC_COMPONENTS_INCLUDE_UTILS_DATA_ACCESSOR_H_
 
+#include <iostream>
 #include "utils/lock.h"
 #include "utils/shared_ptr.h"
 
@@ -39,22 +40,29 @@
 template <class T>
 class DataAccessor {
  public:
-  DataAccessor(const T& data, const sync_primitives::Lock& lock)
+  DataAccessor(const T& data,
+               const std::shared_ptr<sync_primitives::Lock>& lock)
       : data_(data)
-      , lock_(const_cast<sync_primitives::Lock&>(lock))
+      , lock_(const_cast<std::shared_ptr<sync_primitives::Lock> &>(lock))
       , counter_(new uint32_t(0)) {
-    lock_.Acquire();
+    lock_->Acquire();
+    // std::cerr << "new DA constructed! \n";
   }
 
   DataAccessor(const DataAccessor<T>& other)
       : data_(other.data_), lock_(other.lock_), counter_(other.counter_) {
     ++(*counter_);
+    // std::cerr << "DA copied with count " << *counter_ << "\n";
   }
 
   ~DataAccessor() {
     if (0 == *counter_) {
-      lock_.Release();
+      // std::cerr << "releasing lock in DA destructor!!\n";
+      lock_->Release();
     } else {
+      // std::cerr << "ignoring lock in DA destructor!! count is " << *counter_
+      //           << "\n";
+      ;
       --(*counter_);
     }
   }
@@ -65,7 +73,8 @@ class DataAccessor {
  private:
   void* operator new(size_t size);
   const T& data_;
-  sync_primitives::Lock& lock_;
+  // Require that the lock lives at least as long as the DataAccessor
+  std::shared_ptr<sync_primitives::Lock> lock_;
   utils::SharedPtr<uint32_t> counter_;
 };
 
diff --git a/src/components/include/utils/lock.h b/src/components/include/utils/lock.h
index e615a58f9d..f97ef4fb14 100644
--- a/src/components/include/utils/lock.h
+++ b/src/components/include/utils/lock.h
@@ -39,8 +39,9 @@
 #error Please implement lock for your OS
 #endif
 #include <stdint.h>
-#include "utils/macro.h"
+#include <memory>
 #include "utils/atomic.h"
+#include "utils/macro.h"
 #include "utils/memory_barrier.h"
 
 namespace sync_primitives {
@@ -115,15 +116,15 @@ class Lock {
 
 #ifndef NDEBUG
   /**
-  * @brief Basic debugging aid, a flag that signals wether this lock is
-  * currently taken
-  * Allows detection of abandoned and recursively captured mutexes
-  */
+   * @brief Basic debugging aid, a flag that signals wether this lock is
+   * currently taken
+   * Allows detection of abandoned and recursively captured mutexes
+   */
   uint32_t lock_taken_;
 
   /**
-  * @brief Describe if mutex is recurcive or not
-  */
+   * @brief Describe if mutex is recurcive or not
+   */
   bool is_mutex_recursive_;
 
   void AssertFreeAndMarkTaken();
@@ -145,6 +146,10 @@ class AutoLock {
   explicit AutoLock(Lock& lock) : lock_(lock) {
     lock_.Acquire();
   }
+  // Autolock a shared pointer to a lock
+  explicit AutoLock(std::shared_ptr<Lock>& lock) : lock_(*lock) {
+    lock_.Acquire();
+  }
   ~AutoLock() {
     lock_.Release();
   }
@@ -180,5 +185,9 @@ class AutoUnlock {
  private:
   DISALLOW_COPY_AND_ASSIGN(AutoUnlock);
 };
+
+// For easy reference to
+typedef std::shared_ptr<Lock> LockSPtr;
+
 }  // namespace sync_primitives
 #endif  // SRC_COMPONENTS_INCLUDE_UTILS_LOCK_H_
diff --git a/src/components/utils/src/lock_posix.cc b/src/components/utils/src/lock_posix.cc
index 9b90ad20b9..b771a57726 100644
--- a/src/components/utils/src/lock_posix.cc
+++ b/src/components/utils/src/lock_posix.cc
@@ -37,6 +37,8 @@
 #include <string.h>
 #include <cstring>
 #include "utils/logger.h"
+#include <iostream>
+#include <signal.h>
 
 namespace sync_primitives {
 
@@ -63,6 +65,8 @@ Lock::Lock(bool is_recursive)
 Lock::~Lock() {
 #ifndef NDEBUG
   if (lock_taken_ > 0) {
+    std::cerr << "LOCK DESTRUCT ERRROR!!!\n";
+    exit(1);
     LOG4CXX_ERROR(logger_, "Destroying non-released mutex " << &mutex_);
   }
 #endif
@@ -77,6 +81,8 @@ Lock::~Lock() {
 void Lock::Acquire() {
   const int32_t status = pthread_mutex_lock(&mutex_);
   if (status != 0) {
+    std::cerr << "LOCK ACQUIRE ERRROR!!!\n";
+    exit(1);
     LOG4CXX_FATAL(logger_,
                   "Failed to acquire mutex " << &mutex_ << ": "
                                              << strerror(status));
@@ -90,6 +96,8 @@ void Lock::Release() {
   AssertTakenAndMarkFree();
   const int32_t status = pthread_mutex_unlock(&mutex_);
   if (status != 0) {
+    std::cerr << "LOCK RELEASE ERRROR!!!\n";
+    exit(1);
     LOG4CXX_ERROR(logger_,
                   "Failed to unlock mutex" << &mutex_ << ": "
                                            << strerror(status));
diff --git a/src/components/utils/test/data_accessor_test.cc b/src/components/utils/test/data_accessor_test.cc
index c7c728b676..0b31e584e2 100644
--- a/src/components/utils/test/data_accessor_test.cc
+++ b/src/components/utils/test/data_accessor_test.cc
@@ -41,7 +41,7 @@ namespace utils_test {
 TEST(DataAccessorTest, CreateDataAccessor) {
   // arrange
   int test_value = 10;
-  sync_primitives::Lock testSet_lock_;
+  std::shared_ptr<sync_primitives::Lock> testSet_lock_ = std::make_shared<sync_primitives::Lock>();
   DataAccessor<int> testdata(test_value, testSet_lock_);
   int data_from_testdata = testdata.GetData();
 
@@ -52,17 +52,17 @@ TEST(DataAccessorTest, CreateDataAccessor) {
 TEST(DataAccessorTest, CreateDataAccessor_MutexIsLocked_CannotLockItAgain) {
   // arrange
   int test_value = 10;
-  sync_primitives::Lock testSet_lock_;
+  std::shared_ptr<sync_primitives::Lock> testSet_lock_ = std::make_shared<sync_primitives::Lock>();
   DataAccessor<int> testdata(test_value, testSet_lock_);
 
   // assert
-  EXPECT_FALSE(testSet_lock_.Try());
+  EXPECT_FALSE(testSet_lock_->Try());
 }
 
 TEST(DataAccessorTest, CopyDataAccessor_GetDataFromDataAccessors) {
   // arrange
   int test_value = 10;
-  sync_primitives::Lock testSet_lock_;
+  std::shared_ptr<sync_primitives::Lock> testSet_lock_ = std::make_shared<sync_primitives::Lock>();
   DataAccessor<int> testdata(test_value, testSet_lock_);
   DataAccessor<int> testdata_copy(testdata);
 
@@ -72,14 +72,14 @@ TEST(DataAccessorTest, CopyDataAccessor_GetDataFromDataAccessors) {
   // assert
   EXPECT_EQ(data_from_testdata, data_from_testdata_copy);
 
-  EXPECT_FALSE(testSet_lock_.Try());
+  EXPECT_FALSE(testSet_lock_->Try());
 }
 
 TEST(DataAccessorTest,
      ChangedDataInDataAccessor_ChangeData_DataInDataAccessorIsChanged) {
   // arrange
   int test_value = 10;
-  sync_primitives::Lock testSet_lock_;
+  std::shared_ptr<sync_primitives::Lock> testSet_lock_ = std::make_shared<sync_primitives::Lock>();
   DataAccessor<int> testdata(test_value, testSet_lock_);
   test_value = 0;
 
@@ -93,40 +93,40 @@ TEST(DataAccessorTest,
      DeleteDataAccessor_CreatedOneDeleteOneThread_MutexIsUnlocked) {
   // arrange
   int test_value = 10;
-  sync_primitives::Lock testSet_lock_;
+  std::shared_ptr<sync_primitives::Lock> testSet_lock_ = std::make_shared<sync_primitives::Lock>();
   {
     DataAccessor<int> testdata(test_value, testSet_lock_);
 
     // assert
-    EXPECT_FALSE(testSet_lock_.Try());
+    EXPECT_FALSE(testSet_lock_->Try());
   }
   // assert
 
-  EXPECT_TRUE(testSet_lock_.Try());
+  EXPECT_TRUE(testSet_lock_->Try());
 
-  testSet_lock_.Release();
+  testSet_lock_->Release();
 }
 
 TEST(DataAccessorTest,
      DeleteDataAccessor_CreatedThreadAndCopyDeleteBothThreads_MutexIsUnlocked) {
   // arrange
   int test_value = 10;
-  sync_primitives::Lock testSet_lock_;
+  std::shared_ptr<sync_primitives::Lock> testSet_lock_ = std::make_shared<sync_primitives::Lock>();
   {
     DataAccessor<int> testdata(test_value, testSet_lock_);
     {
       DataAccessor<int> testdata_copy(testdata);
 
       // assert
-      EXPECT_FALSE(testSet_lock_.Try());
+      EXPECT_FALSE(testSet_lock_->Try());
     }
     // assert
-    EXPECT_FALSE(testSet_lock_.Try());
+    EXPECT_FALSE(testSet_lock_->Try());
   }
 
   // assert
-  EXPECT_TRUE(testSet_lock_.Try());
-  testSet_lock_.Release();
+  EXPECT_TRUE(testSet_lock_->Try());
+  testSet_lock_->Release();
 }
 
 }  // namespace utils_test