Fix/SDL memory leaks

src/components/application_manager/src/application_data_impl.cc

@@ -244,6 +244,21 @@ DynamicApplicationDataImpl::~DynamicApplicationDataImpl() {
     show_command_ = NULL;
   }
 
+  if (keyboard_props_) {
+    delete keyboard_props_;
+    keyboard_props_ = nullptr;
+  }
+
+  if (menu_title_) {
+    delete menu_title_;
+    menu_title_ = nullptr;
+  }
+
+  if (menu_icon_) {
+    delete menu_icon_;
+    menu_icon_ = nullptr;
+  }
+
   if (tbt_show_command_) {
     delete tbt_show_command_;
     tbt_show_command_ = NULL;

src/components/application_manager/src/hmi_capabilities_impl.cc

@@ -471,6 +471,7 @@ HMICapabilitiesImpl::~HMICapabilitiesImpl() {
   delete phone_capability_;
   delete video_streaming_capability_;
   delete rc_capability_;
+  delete seat_location_capability_;
 }
 
 bool HMICapabilitiesImpl::VerifyImageType(const int32_t image_type) const {

src/components/application_manager/test/application_manager_impl_test.cc

@@ -713,6 +713,8 @@ TEST_F(ApplicationManagerImplTest,
   app_manager_impl_->OnServiceStartedCallback(
       device_handle, session_key, service_type, &input_params);
 
+  bson_object_deinitialize(&input_params);
+
   // check: return value is true and list is empty
   EXPECT_TRUE(result);
   EXPECT_TRUE(rejected_params.empty());
@@ -806,6 +808,8 @@ TEST_F(ApplicationManagerImplTest,
   app_manager_impl_->OnServiceStartedCallback(
       device_handle, session_key, service_type, &input_params);
 
+  bson_object_deinitialize(&input_params);
+
   // check: return value is false
   EXPECT_FALSE(result);
 
@@ -854,6 +858,8 @@ TEST_F(ApplicationManagerImplTest,
   app_manager_impl_->OnServiceStartedCallback(
       device_handle, session_key, service_type, &input_params);
 
+  bson_object_deinitialize(&input_params);
+
   // check: return value is true and list is empty
   EXPECT_TRUE(result);
   EXPECT_TRUE(rejected_params.empty());
@@ -939,6 +945,8 @@ TEST_F(ApplicationManagerImplTest,
   app_manager_impl_->OnServiceStartedCallback(
       device_handle, session_key, service_type, &input_params);
 
+  bson_object_deinitialize(&input_params);
+
   // check: return value is true and list is empty
   EXPECT_TRUE(result);
   EXPECT_TRUE(rejected_params.empty());

src/components/application_manager/test/include/application_manager/resumption_data_test.h

@@ -63,7 +63,15 @@ using namespace mobile_apis;
 class ResumptionDataTest : public ::testing::Test {
  protected:
   ResumptionDataTest()
-      : kCountOfCommands_(5u)
+      : help_prompt_(nullptr)
+      , timeout_prompt_(nullptr)
+      , vr_help_(nullptr)
+      , vr_help_title_(nullptr)
+      , vr_synonyms_(nullptr)
+      , keyboard_props_(nullptr)
+      , menu_title_(nullptr)
+      , menu_icon_(nullptr)
+      , kCountOfCommands_(5u)
       , kCountOfChoice_(2u)
       , kCountOfChoiceSets_(4u)
       , kCountOfSubmenues_(3u)
@@ -77,6 +85,8 @@ class ResumptionDataTest : public ::testing::Test {
       , ivilock_ptr_(std::make_shared<sync_primitives::Lock>())
       , window_params_map_lock_ptr_(std::make_shared<sync_primitives::Lock>()) {
   }
+
+  ~ResumptionDataTest();
   // Check structure in saved application
   void CheckSavedApp(sm::SmartObject& saved_data);
   // Set data for resumption

src/components/application_manager/test/mobile_message_handler_test.cc

@@ -128,8 +128,8 @@ class MobileMessageHandlerTest : public testing::Test {
 
     // Act
     size_t payload_size = data.size();
-    Message* message = HandleIncomingMessage(
-        protocol_version, json_plus_binary_data, payload_size);
+    const auto message = std::unique_ptr<Message>(HandleIncomingMessage(
+        protocol_version, json_plus_binary_data, payload_size));
 
     // Checks
     EXPECT_EQ(data, message->json_message());
@@ -148,8 +148,8 @@ class MobileMessageHandlerTest : public testing::Test {
     // Arrange
     size_t payload_size = data.size();
     size_t full_data_size = data.size() + PROTOCOL_HEADER_V2_SIZE;
-    Message* message =
-        HandleIncomingMessage(protocol_version, data, payload_size);
+    const auto message = std::unique_ptr<Message>(
+        HandleIncomingMessage(protocol_version, data, payload_size));
 
     // Checks
     EXPECT_EQ(data, message->json_message());
@@ -197,8 +197,8 @@ class MobileMessageHandlerTest : public testing::Test {
     MobileMessage message_to_send = CreateMessageForSending(
         protocol_version, function_id, correlation_id, connection_key, data);
     // Act
-    RawMessage* result_message =
-        MobileMessageHandler::HandleOutgoingMessageProtocol(message_to_send);
+    const std::unique_ptr<RawMessage> result_message(
+        MobileMessageHandler::HandleOutgoingMessageProtocol(message_to_send));
 
     std::vector<uint8_t> full_data = joiner<std::vector<uint8_t> >(
         binary_header, binary_header + PROTOCOL_HEADER_V2_SIZE, data);
@@ -218,9 +218,8 @@ class MobileMessageHandlerTest : public testing::Test {
   void TestHandlingOutgoingMessageProtocolWithBinaryData(
       const uint32_t protocol_version) {
     // Arrange
-    application_manager::BinaryData* bin_dat =
-        new application_manager::BinaryData;
-    bin_dat->push_back('\a');
+    application_manager::BinaryData bin_dat;
+    bin_dat.push_back('\a');
 
     const uint32_t function_id = 247u;
     const uint32_t correlation_id = 92u;
@@ -231,14 +230,14 @@ class MobileMessageHandlerTest : public testing::Test {
                                                             correlation_id,
                                                             connection_key,
                                                             data,
-                                                            bin_dat);
+                                                            &bin_dat);
     // Act
-    RawMessage* result_message =
-        MobileMessageHandler::HandleOutgoingMessageProtocol(message_to_send);
+    const std::unique_ptr<RawMessage> result_message(
+        MobileMessageHandler::HandleOutgoingMessageProtocol(message_to_send));
     std::vector<uint8_t> full_data = joiner<std::vector<uint8_t> >(
         binary_header, binary_header + PROTOCOL_HEADER_V2_SIZE, data);
     size_t full_size =
-        sizeof(uint8_t) * full_data.size() + bin_dat->size() * sizeof(uint8_t);
+        sizeof(uint8_t) * full_data.size() + bin_dat.size() * sizeof(uint8_t);
 
     // Checks
     EXPECT_EQ(protocol_version, result_message->protocol_version());

src/components/application_manager/test/mobile_message_handler_v1_test.cc

@@ -75,10 +75,10 @@ TEST(MobileMessageHandlerTestV1Test,
                                                        data_json.length(),
                                                        false);
 
-  application_manager::Message* ptr =
-      MobileMessageHandler::HandleIncomingMessageProtocol(message);
+  const std::unique_ptr<application_manager::Message> ptr(
+      MobileMessageHandler::HandleIncomingMessageProtocol(message));
 
-  ASSERT_TRUE(ptr);
+  ASSERT_TRUE(ptr.get());
 
   EXPECT_EQ(connection_key_p1, ptr->connection_key());
   EXPECT_EQ(protocol_version_1, ptr->protocol_version());
@@ -98,10 +98,10 @@ TEST(MobileMessageHandlerTestV1Test,
                                                        full_data.length(),
                                                        false);
 
-  application_manager::Message* ptr =
-      MobileMessageHandler::HandleIncomingMessageProtocol(message);
+  const auto ptr = std::unique_ptr<application_manager::Message>(
+      MobileMessageHandler::HandleIncomingMessageProtocol(message));
 
-  ASSERT_TRUE(ptr);
+  ASSERT_TRUE(ptr.get());
 
   EXPECT_EQ(connection_key_p1, ptr->connection_key());
   EXPECT_EQ(protocol_version_1, ptr->protocol_version());
@@ -121,10 +121,10 @@ TEST(MobileMessageHandlerTestV1Test,
   message->set_json_message(data_json);
   message->set_connection_key(connection_key_p1);
 
-  RawMessage* ptr =
-      MobileMessageHandler::HandleOutgoingMessageProtocol(message);
+  const std::unique_ptr<RawMessage> ptr(
+      MobileMessageHandler::HandleOutgoingMessageProtocol(message));
 
-  ASSERT_TRUE(ptr);
+  ASSERT_TRUE(ptr.get());
 
   EXPECT_EQ(connection_key, ptr->connection_key());
   EXPECT_EQ(static_cast<uint32_t>(

src/components/application_manager/test/resumption/resumption_data_test.cc

@@ -52,6 +52,66 @@ using ::testing::Return;
 using ::testing::ReturnPointee;
 using ::testing::ReturnRef;
 
+ResumptionDataTest::~ResumptionDataTest() {
+  for (auto& submenu : test_submenu_map) {
+    delete submenu.second;
+  }
+
+  test_submenu_map.clear();
+
+  for (auto& command : test_commands_map) {
+    delete command.second;
+  }
+
+  test_commands_map.clear();
+
+  for (auto& choiceset : test_choiceset_map) {
+    delete choiceset.second;
+  }
+
+  test_choiceset_map.clear();
+
+  if (help_prompt_) {
+    delete help_prompt_;
+    help_prompt_ = nullptr;
+  }
+
+  if (timeout_prompt_) {
+    delete timeout_prompt_;
+    timeout_prompt_ = nullptr;
+  }
+
+  if (vr_help_) {
+    delete vr_help_;
+    vr_help_ = nullptr;
+  }
+
+  if (vr_help_title_) {
+    delete vr_help_title_;
+    vr_help_title_ = nullptr;
+  }
+
+  if (vr_synonyms_) {
+    delete vr_synonyms_;
+    vr_synonyms_ = nullptr;
+  }
+
+  if (keyboard_props_) {
+    delete keyboard_props_;
+    keyboard_props_ = nullptr;
+  }
+
+  if (menu_title_) {
+    delete menu_title_;
+    menu_title_ = nullptr;
+  }
+
+  if (menu_icon_) {
+    delete menu_icon_;
+    menu_icon_ = nullptr;
+  }
+}
+
 void ResumptionDataTest::CheckSavedApp(sm::SmartObject& resume_app_list) {
   EXPECT_EQ(policy_app_id_, resume_app_list[am::strings::app_id].asString());
   EXPECT_EQ(grammar_id_, resume_app_list[am::strings::grammar_id].asUInt());
@@ -442,7 +502,17 @@ void ResumptionDataTest::SetMenuTitleAndIcon() {
 
   sm::SmartObject sm_title;
   sm_title = "test title";
+
+  if (menu_title_) {
+    delete menu_title_;
+  }
+
   menu_title_ = new sm::SmartObject(sm_title);
+
+  if (menu_icon_) {
+    delete menu_icon_;
+  }
+
   menu_icon_ = new sm::SmartObject(sm_icon);
 }
 
@@ -456,14 +526,24 @@ void ResumptionDataTest::SetHelpAndTimeoutPrompt() {
     help_prompt[i][am::strings::text] = "help prompt name" + std::string(numb);
     help_prompt[i][am::strings::type] = SpeechCapabilities::PRE_RECORDED;
   }
+
+  if (help_prompt_) {
+    delete help_prompt_;
+  }
+
   help_prompt_ = new sm::SmartObject(help_prompt);
+
   for (uint i = 0; i < tts_chunks_count; ++i) {
     char numb[12];
     std::snprintf(numb, 12, "%d", i);
     timeout_prompt[i][am::strings::text] = "timeout test" + std::string(numb);
     timeout_prompt[i][am::strings::type] = SpeechCapabilities::SC_TEXT;
   }
 
+  if (timeout_prompt_) {
+    delete timeout_prompt_;
+  }
+
   timeout_prompt_ = new sm::SmartObject(timeout_prompt);
 }
 
@@ -479,7 +559,16 @@ void ResumptionDataTest::SetVRHelpTitle() {
     vr_help[i][am::strings::position] = i;
   }
 
+  if (vr_help_) {
+    delete vr_help_;
+  }
+
   vr_help_ = new sm::SmartObject(vr_help);
+
+  if (vr_help_title_) {
+    delete vr_help_title_;
+  }
+
   vr_help_title_ = new sm::SmartObject(vr_help_title);
 }
 
@@ -591,6 +680,11 @@ void ResumptionDataTest::SetKeyboardProperties() {
   keyboard[am::strings::auto_complete_text] = "complete";
   keyboard[am::strings::limited_character_list][0] = "y";
   keyboard[am::strings::limited_character_list][1] = "n";
+
+  if (keyboard_props_) {
+    delete keyboard_props_;
+  }
+
   keyboard_props_ = new sm::SmartObject(keyboard);
 }
 

src/components/include/utils/threads/async_runner.h

@@ -82,6 +82,8 @@ class AsyncRunner {
    public:
     AsyncRunnerDelegate();
 
+    ~AsyncRunnerDelegate();
+
     /**
      * @brief threadMain runs delegates queue handling.
      */
@@ -111,7 +113,13 @@ class AsyncRunner {
      */
     void waitForDelegate();
 
-    std::queue<threads::ThreadDelegate*> delegates_queue_;
+    /**
+     * @bref ClearDelegateQueue delete leftover delegates in the queue
+     */
+    void ClearDelegateQueue();
+
+    typedef std::queue<threads::ThreadDelegate*> DelegatesQueue;
+    DelegatesQueue delegates_queue_;
     sync_primitives::ConditionalVariable delegate_notifier_;
     sync_primitives::Lock delegates_queue_lock_;
     volatile bool stop_flag_;

src/components/policy/policy_regular/include/policy/cache_manager.h

@@ -900,7 +900,8 @@ class CacheManager : public CacheManagerInterface {
    * @brief Checks snapshot initialization and initializes to default values, if
    * necessary
    */
-  void CheckSnapshotInitialization();
+  void CheckSnapshotInitialization(
+      std::shared_ptr<policy_table::Table>& snapshot);
 
   /**
    * @brief Calculates difference between two provided custom vehicle data items
@@ -941,7 +942,6 @@ class CacheManager : public CacheManagerInterface {
 
  private:
   std::shared_ptr<policy_table::Table> pt_;
-  std::shared_ptr<policy_table::Table> snapshot_;
   std::shared_ptr<PTRepresentation> backup_;
   bool update_required;
   typedef std::set<std::string> UnpairedDevices;