1 files changed, 70 insertions, 97 deletions

diff --git a/src/components/connection_handler/src/connection_handler_impl.cc b/src/components/connection_handler/src/connection_handler_impl.cc
index 89910df6e7..261a8d232c 100644
--- a/src/components/connection_handler/src/connection_handler_impl.cc
+++ b/src/components/connection_handler/src/connection_handler_impl.cc
@@ -38,18 +38,11 @@
 
 #include "connection_handler/connection_handler_impl.h"
 #include "transport_manager/info.h"
-#include "config_profile/profile.h"
 
 #ifdef ENABLE_SECURITY
 #include "security_manager/security_manager.h"
 #endif  // ENABLE_SECURITY
 
-namespace {
-uint32_t HeartBeatTimeout() {
-  return profile::Profile::instance()->heart_beat_timeout();
-}
-}  // namespace
-
 /**
  * \namespace connection_handler
  * \brief SmartDeviceLink ConnectionHandler namespace.
@@ -67,12 +60,15 @@ transport_manager::ConnectionUID ConnectionUIDFromHandle(
   return transport_manager::ConnectionUID(handle);
 }
 
-ConnectionHandlerImpl::ConnectionHandlerImpl()
-  : connection_handler_observer_(NULL),
-    transport_manager_(NULL),
-    protocol_handler_(NULL),
-    connection_handler_observer_lock_(true),
-    connection_list_deleter_(&connection_list_) {
+ConnectionHandlerImpl::ConnectionHandlerImpl(
+    const ConnectionHandlerSettings& settings,
+    transport_manager::TransportManager& tm)
+    : settings_(settings)
+    , connection_handler_observer_(NULL)
+    , transport_manager_(tm)
+    , protocol_handler_(NULL)
+    , connection_handler_observer_lock_(true)
+    , connection_list_deleter_(&connection_list_) {
 }
 
 ConnectionHandlerImpl::~ConnectionHandlerImpl() {
@@ -99,17 +95,6 @@ void ConnectionHandlerImpl::set_connection_handler_observer(
   connection_handler_observer_ = observer;
 }
 
-void ConnectionHandlerImpl::set_transport_manager(
-    transport_manager::TransportManager *transport_mngr) {
-  LOG4CXX_DEBUG(logger_, "ConnectionHandlerImpl::set_transport_manager() "
-                << transport_mngr);
-  if (!transport_mngr) {
-    LOG4CXX_ERROR(logger_, "Null pointer to TransportManager.");
-    return;
-  }
-  transport_manager_ = transport_mngr;
-}
-
 void ConnectionHandlerImpl::set_protocol_handler(
     protocol_handler::ProtocolHandler *protocol_handler) {
   LOG4CXX_DEBUG(logger_, "ConnectionHandlerImpl::set_protocol_handler()"
@@ -194,7 +179,7 @@ void ConnectionHandlerImpl::OnScanDevicesFailed(
 
 void ConnectionHandlerImpl::OnConnectionEstablished(
     const transport_manager::DeviceInfo &device_info,
-    const transport_manager::ConnectionUID &connection_id) {
+    const transport_manager::ConnectionUID connection_id) {
   LOG4CXX_AUTO_TRACE(logger_);
 
   DeviceMap::iterator it = device_list_.find(device_info.device_handle());
@@ -208,7 +193,7 @@ void ConnectionHandlerImpl::OnConnectionEstablished(
       ConnectionList::value_type(
           connection_id,
           new Connection(connection_id, device_info.device_handle(), this,
-                         HeartBeatTimeout())));
+                         get_settings().heart_beat_timeout())));
 }
 
 void ConnectionHandlerImpl::OnConnectionFailed(
@@ -262,39 +247,28 @@ void ConnectionHandlerImpl::RemoveConnection(
 }
 
 #ifdef ENABLE_SECURITY
-namespace {
-bool AllowProtection(const protocol_handler::ServiceType &service_type,
-                          const bool is_protected) {
-  if (is_protected) {
-    // Check deliver-specific services (which shall not be protected)
-    const std::list<int> force_unprotected_list =
-        profile::Profile::instance()->ReadIntContainer(
-          "Security Manager", "ForceUnprotectedService", NULL);
-    if (std::find(force_unprotected_list.begin(), force_unprotected_list.end(), service_type) !=
-        force_unprotected_list.end()) {
-      LOG4CXX_ERROR(logger_, "Service " << static_cast<int>(service_type)
-                    << " is forbidden to be protected");
-      return false;
-    }
-  } else {
-    // Check deliver-specific services (which shall be protected)
-    const std::list<int> force_protected_list =
-        profile::Profile::instance()->ReadIntContainer(
-          "Security Manager", "ForceProtectedService", NULL);
-    if (std::find(force_protected_list.begin(), force_protected_list.end(), service_type) !=
-        force_protected_list.end()) {
-      LOG4CXX_ERROR(logger_, "Service " << static_cast<int>(service_type)
-                    << " shall be protected");
-      return false;
-    }
+bool AllowProtection(const ConnectionHandlerSettings& settings,
+                     const protocol_handler::ServiceType& service_type,
+                     const bool is_protected) {
+  const std::vector<int>& force_unprotected_list =
+      is_protected ? settings.force_unprotected_service()
+                   : settings.force_protected_service();
+
+  if (std::find(force_unprotected_list.begin(), force_unprotected_list.end(), service_type) !=
+      force_unprotected_list.end()) {
+    LOG4CXX_ERROR(logger_,
+                  "Service " << static_cast<int>(service_type)
+                             << " shall be protected");
+    return false;
   }
+  LOG4CXX_DEBUG(logger_,
+                "Service " << static_cast<int>(service_type) << " allowed");
   return true;
 }
-}  // namespace
 #endif  // ENABLE_SECURITY
 
 uint32_t ConnectionHandlerImpl::OnSessionStartedCallback(
-    const transport_manager::ConnectionUID &connection_handle,
+    const transport_manager::ConnectionUID connection_handle,
     const uint8_t session_id, const protocol_handler::ServiceType &service_type,
     const bool is_protected, uint32_t* hash_id) {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -303,7 +277,7 @@ uint32_t ConnectionHandlerImpl::OnSessionStartedCallback(
     *hash_id = protocol_handler::HASH_ID_WRONG;
   }
 #ifdef ENABLE_SECURITY
-  if (!AllowProtection(service_type, is_protected)) {
+  if (!AllowProtection(get_settings(), service_type, is_protected)) {
     return 0;
   }
 #endif  // ENABLE_SECURITY
@@ -389,7 +363,8 @@ void ConnectionHandlerImpl::OnMalformedMessageCallback(
 }
 
 uint32_t ConnectionHandlerImpl::OnSessionEndedCallback(
-    const uint32_t &connection_handle, const uint8_t session_id,
+    const transport_manager::ConnectionUID connection_handle,
+    const uint8_t session_id,
     const uint32_t &hashCode,
     const protocol_handler::ServiceType &service_type) {
   LOG4CXX_AUTO_TRACE(logger_);
@@ -442,7 +417,8 @@ uint32_t ConnectionHandlerImpl::OnSessionEndedCallback(
 }
 
 uint32_t ConnectionHandlerImpl::KeyFromPair(
-    transport_manager::ConnectionUID connection_handle, uint8_t session_id) {
+    transport_manager::ConnectionUID connection_handle,
+    uint8_t session_id) const {
   const uint32_t key = connection_handle | (session_id << 16);
   LOG4CXX_DEBUG(logger_, "Key for ConnectionHandle:"
                 << static_cast<uint32_t>(connection_handle)
@@ -456,8 +432,8 @@ uint32_t ConnectionHandlerImpl::KeyFromPair(
 }
 
 void ConnectionHandlerImpl::PairFromKey(uint32_t key,
-                                        uint32_t *connection_handle,
-                                        uint8_t *session_id) {
+                                        transport_manager::ConnectionUID *connection_handle,
+                                        uint8_t *session_id) const {
   *connection_handle = key & 0xFF00FFFF;
   *session_id = key >> 16;
   LOG4CXX_DEBUG(logger_, "ConnectionHandle:"
@@ -468,7 +444,7 @@ void ConnectionHandlerImpl::PairFromKey(uint32_t key,
 
 int32_t ConnectionHandlerImpl::GetDataOnSessionKey(
     uint32_t key, uint32_t* app_id, std::list<int32_t>* sessions_list,
-    uint32_t* device_id) {
+    uint32_t* device_id) const  {
   LOG4CXX_AUTO_TRACE(logger_);
 
   const int32_t error_result = -1;
@@ -476,7 +452,7 @@ int32_t ConnectionHandlerImpl::GetDataOnSessionKey(
   uint8_t session_id = 0;
   PairFromKey(key, &conn_handle, &session_id);
 
-  ConnectionList::iterator it = connection_list_.find(conn_handle);
+  ConnectionList::const_iterator it = connection_list_.find(conn_handle);
   if (connection_list_.end() == it) {
     LOG4CXX_ERROR(logger_, "Connection not found for key: " << key);
     return error_result;
@@ -512,6 +488,20 @@ int32_t ConnectionHandlerImpl::GetDataOnSessionKey(
   return 0;
 }
 
+const ConnectionHandlerSettings& ConnectionHandlerImpl::get_settings() const
+{
+  return settings_;
+}
+
+const protocol_handler::SessionObserver&
+ConnectionHandlerImpl::get_session_observer() {
+  return *this;
+}
+
+DevicesDiscoveryStarter& ConnectionHandlerImpl::get_device_discovery_starter() {
+  return *this;
+}
+
 struct CompareMAC {
   explicit CompareMAC(const std::string &mac) : mac_(mac) {}
   bool operator() (const DeviceMap::value_type &device) {
@@ -539,11 +529,11 @@ int32_t ConnectionHandlerImpl::GetDataOnDeviceID(
     DeviceHandle device_handle,
     std::string *device_name,
     std::list<uint32_t> *applications_list, std::string *mac_address,
-    std::string* connection_type ) {
+    std::string* connection_type ) const {
   LOG4CXX_AUTO_TRACE(logger_);
 
   int32_t result = -1;
-  DeviceMap::iterator it = device_list_.find(device_handle);
+  DeviceMap::const_iterator it = device_list_.find(device_handle);
   if (device_list_.end() == it) {
     LOG4CXX_ERROR(logger_, "Device not found!");
     return result;
@@ -558,13 +548,13 @@ int32_t ConnectionHandlerImpl::GetDataOnDeviceID(
   if (applications_list) {
     applications_list->clear();
     sync_primitives::AutoReadLock connection_list_lock(connection_list_lock_);
-    for (ConnectionList::iterator itr = connection_list_.begin();
+    for (ConnectionList::const_iterator itr = connection_list_.begin();
         itr != connection_list_.end(); ++itr) {
       if (device_handle == (*itr).second->connection_device_handle()) {
         const SessionMap &session_map = (itr->second)->session_map();
         for (SessionMap::const_iterator session_it = session_map.begin();
              session_map.end() != session_it; ++session_it) {
-          const transport_manager::ConnectionUID &connection_handle = itr->first;
+          const transport_manager::ConnectionUID connection_handle = itr->first;
           const uint32_t session_id = session_it->first;
           const uint32_t application_id = KeyFromPair(connection_handle, session_id);
           applications_list->push_back(application_id);
@@ -654,11 +644,7 @@ ConnectionHandlerImpl::GetHandshakeContext(uint32_t key) const {
 void ConnectionHandlerImpl::StartDevicesDiscovery() {
   LOG4CXX_AUTO_TRACE(logger_);
 
-  if (NULL == transport_manager_) {
-    LOG4CXX_ERROR(logger_, "Null pointer to TransportManager.");
-    return;
-  }
-  transport_manager_->SearchDevices();
+  transport_manager_.SearchDevices();
   sync_primitives::AutoLock lock(connection_handler_observer_lock_);
   if (connection_handler_observer_) {
     connection_handler_observer_->OnDeviceListUpdated(device_list_);
@@ -672,17 +658,13 @@ void ConnectionHandlerImpl::ConnectToDevice(
   if (device_list_.end() != it_in) {
     LOG4CXX_INFO(logger_,
                      "Connecting to device with handle " << device_handle);
-    if (transport_manager_) {
-      if (transport_manager::E_SUCCESS
-          != transport_manager_->ConnectDevice(device_handle)) {
-        LOG4CXX_WARN(logger_, "Can't connect to device");
-      }
+    if (transport_manager::E_SUCCESS
+        != transport_manager_.ConnectDevice(device_handle)) {
+      LOG4CXX_WARN(logger_, "Can't connect to device");
     } else {
-      LOG4CXX_ERROR(logger_, "Null pointer to TransportManager.");
+      LOG4CXX_ERROR(
+          logger_, "Application Manager wanted to connect to non-existing device");
     }
-  } else {
-    LOG4CXX_ERROR(
-        logger_, "Application Manager wanted to connect to non-existing device");
   }
 }
 
@@ -695,12 +677,7 @@ void ConnectionHandlerImpl::ConnectToAllDevices() {
 
 void ConnectionHandlerImpl::StartTransportManager() {
   LOG4CXX_AUTO_TRACE(logger_);
-  if (NULL == transport_manager_) {
-    LOG4CXX_ERROR(logger_, "Null pointer to TransportManager.");
-    return;
-  }
-
-  transport_manager_->Visibility(true);
+  transport_manager_.Visibility(true);
 }
 
 void ConnectionHandlerImpl::CloseRevokedConnection(uint32_t connection_key) {
@@ -716,13 +693,9 @@ void ConnectionHandlerImpl::CloseRevokedConnection(uint32_t connection_key) {
 void ConnectionHandlerImpl::CloseConnection(
     ConnectionHandle connection_handle) {
   LOG4CXX_AUTO_TRACE(logger_);
-  if (!transport_manager_) {
-    LOG4CXX_ERROR(logger_, "Null pointer to TransportManager.");
-    return;
-  }
   transport_manager::ConnectionUID connection_uid =
       ConnectionUIDFromHandle(connection_handle);
-  transport_manager_->DisconnectForce(connection_uid);
+  transport_manager_.DisconnectForce(connection_uid);
 
   sync_primitives::AutoWriteLock connection_list_lock(connection_list_lock_);
 
@@ -910,7 +883,7 @@ void ConnectionHandlerImpl::KeepConnectionAlive(uint32_t connection_key,
 }
 
 void ConnectionHandlerImpl::OnConnectionEnded(
-    const transport_manager::ConnectionUID &connection_id) {
+    const transport_manager::ConnectionUID connection_id) {
   LOG4CXX_INFO(logger_, "Delete Connection: " << static_cast<int32_t>(connection_id)
                << " from the list.");
   connection_list_lock_.AcquireForWriting();
@@ -955,11 +928,12 @@ void ConnectionHandlerImpl::BindProtocolVersionWithSession(
 }
 
 bool ConnectionHandlerImpl::IsHeartBeatSupported(
-    transport_manager::ConnectionUID connection_handle,uint8_t session_id) {
+    transport_manager::ConnectionUID connection_handle,
+    uint8_t session_id) const {
   LOG4CXX_AUTO_TRACE(logger_);
   sync_primitives::AutoReadLock lock(connection_list_lock_);
   uint32_t connection = static_cast<uint32_t>(connection_handle);
-  ConnectionList::iterator it = connection_list_.find(connection);
+  ConnectionList::const_iterator it = connection_list_.find(connection);
   if (connection_list_.end() == it) {
     LOG4CXX_WARN(logger_, "Connection not found !");
     return false;
@@ -968,10 +942,10 @@ bool ConnectionHandlerImpl::IsHeartBeatSupported(
 }
 
 bool ConnectionHandlerImpl::ProtocolVersionUsed(uint32_t connection_id,
-          uint8_t session_id, uint8_t& protocol_version) {
+          uint8_t session_id, uint8_t& protocol_version) const {
   LOG4CXX_AUTO_TRACE(logger_);
   sync_primitives::AutoReadLock lock(connection_list_lock_);
-  ConnectionList::iterator it = connection_list_.find(connection_id);
+  ConnectionList::const_iterator it = connection_list_.find(connection_id);
   if (connection_list_.end() != it) {
     return it->second->ProtocolVersion(session_id, protocol_version);
   }
@@ -988,9 +962,8 @@ const DeviceMap& ConnectionHandlerImpl::getDeviceList() {
   return device_list_;
 }
 
-void ConnectionHandlerImpl::addDeviceConnection(
-    const transport_manager::DeviceInfo &device_info,
-    const transport_manager::ConnectionUID &connection_id) {
+void ConnectionHandlerImpl::addDeviceConnection(const transport_manager::DeviceInfo &device_info,
+    const transport_manager::ConnectionUID connection_id) {
   // Add Device
   OnDeviceAdded(device_info);
   // Add connection