diff --git a/src/commands/command_dictionary.cc b/src/commands/command_dictionary.cc
index 8fb7f43..516961f 100644
--- a/src/commands/command_dictionary.cc
+++ b/src/commands/command_dictionary.cc
@@ -62,7 +62,8 @@
         return false;
       }
 
-      new_defs.emplace(full_command_name, std::move(command_def));
+      new_defs.insert(
+          std::make_pair(full_command_name, std::move(command_def)));
       command_iter.Advance();
     }
     package_iter.Advance();
@@ -81,7 +82,7 @@
 
   // Insert new definitions into the global map.
   for (auto& pair : new_defs)
-    definitions_.emplace(pair.first, std::move(pair.second));
+    definitions_.insert(std::make_pair(pair.first, std::move(pair.second)));
   return true;
 }
 
diff --git a/src/commands/command_dictionary_unittest.cc b/src/commands/command_dictionary_unittest.cc
index 5cecd76..7298363 100644
--- a/src/commands/command_dictionary_unittest.cc
+++ b/src/commands/command_dictionary_unittest.cc
@@ -36,7 +36,7 @@
   })");
   CommandDictionary dict;
   EXPECT_TRUE(dict.LoadCommands(*json, nullptr));
-  EXPECT_EQ(1, dict.GetSize());
+  EXPECT_EQ(1u, dict.GetSize());
   EXPECT_NE(nullptr, dict.FindCommand("robot.jump"));
   json = CreateDictionaryValue(R"({
     'base': {
@@ -48,7 +48,7 @@
     }
   })");
   EXPECT_TRUE(dict.LoadCommands(*json, nullptr));
-  EXPECT_EQ(3, dict.GetSize());
+  EXPECT_EQ(3u, dict.GetSize());
   EXPECT_NE(nullptr, dict.FindCommand("robot.jump"));
   EXPECT_NE(nullptr, dict.FindCommand("base.reboot"));
   EXPECT_NE(nullptr, dict.FindCommand("base.shutdown"));
diff --git a/src/commands/command_manager_unittest.cc b/src/commands/command_manager_unittest.cc
index eca5175..2b2b055 100644
--- a/src/commands/command_manager_unittest.cc
+++ b/src/commands/command_manager_unittest.cc
@@ -75,7 +75,7 @@
     }
   })";
   EXPECT_TRUE(manager.LoadCommands(json_str, nullptr));
-  EXPECT_EQ(2, manager.GetCommandDictionary().GetSize());
+  EXPECT_EQ(2u, manager.GetCommandDictionary().GetSize());
   EXPECT_NE(nullptr, manager.GetCommandDictionary().FindCommand("base.reboot"));
   EXPECT_NE(nullptr, manager.GetCommandDictionary().FindCommand("robot._jump"));
 }
@@ -84,7 +84,7 @@
   CommandManager manager;
   ASSERT_TRUE(manager.LoadCommands(kTestVendorCommands, nullptr));
   ASSERT_TRUE(manager.LoadCommands(kTestTestCommands, nullptr));
-  EXPECT_EQ(3, manager.GetCommandDictionary().GetSize());
+  EXPECT_EQ(3u, manager.GetCommandDictionary().GetSize());
   EXPECT_NE(nullptr, manager.GetCommandDictionary().FindCommand("robot._jump"));
   EXPECT_NE(nullptr,
             manager.GetCommandDictionary().FindCommand("robot._speak"));
diff --git a/src/commands/command_queue.cc b/src/commands/command_queue.cc
index e08527b..3d2167f 100644
--- a/src/commands/command_queue.cc
+++ b/src/commands/command_queue.cc
@@ -38,7 +38,8 @@
       }
     }
 
-    CHECK(command_callbacks_.emplace(command_name, callback).second)
+    CHECK(command_callbacks_.insert(std::make_pair(command_name, callback))
+              .second)
         << command_name << " already has handler";
 
   } else {
diff --git a/src/commands/command_queue_unittest.cc b/src/commands/command_queue_unittest.cc
index a9e953e..394ae20 100644
--- a/src/commands/command_queue_unittest.cc
+++ b/src/commands/command_queue_unittest.cc
@@ -84,14 +84,14 @@
 
 TEST_F(CommandQueueTest, Empty) {
   EXPECT_TRUE(queue_.IsEmpty());
-  EXPECT_EQ(0, queue_.GetCount());
+  EXPECT_EQ(0u, queue_.GetCount());
 }
 
 TEST_F(CommandQueueTest, Add) {
   queue_.Add(CreateDummyCommandInstance("base.reboot", "id1"));
   queue_.Add(CreateDummyCommandInstance("base.reboot", "id2"));
   queue_.Add(CreateDummyCommandInstance("base.reboot", "id3"));
-  EXPECT_EQ(3, queue_.GetCount());
+  EXPECT_EQ(3u, queue_.GetCount());
   EXPECT_FALSE(queue_.IsEmpty());
 }
 
@@ -102,31 +102,31 @@
   queue_.Add(CreateDummyCommandInstance("base.reboot", id2));
   EXPECT_FALSE(queue_.IsEmpty());
   EXPECT_FALSE(Remove("dummy"));
-  EXPECT_EQ(2, queue_.GetCount());
+  EXPECT_EQ(2u, queue_.GetCount());
   EXPECT_TRUE(Remove(id1));
-  EXPECT_EQ(1, queue_.GetCount());
+  EXPECT_EQ(1u, queue_.GetCount());
   EXPECT_FALSE(Remove(id1));
-  EXPECT_EQ(1, queue_.GetCount());
+  EXPECT_EQ(1u, queue_.GetCount());
   EXPECT_TRUE(Remove(id2));
-  EXPECT_EQ(0, queue_.GetCount());
+  EXPECT_EQ(0u, queue_.GetCount());
   EXPECT_FALSE(Remove(id2));
-  EXPECT_EQ(0, queue_.GetCount());
+  EXPECT_EQ(0u, queue_.GetCount());
   EXPECT_TRUE(queue_.IsEmpty());
 }
 
 TEST_F(CommandQueueTest, DelayedRemove) {
   const std::string id1 = "id1";
   queue_.Add(CreateDummyCommandInstance("base.reboot", id1));
-  EXPECT_EQ(1, queue_.GetCount());
+  EXPECT_EQ(1u, queue_.GetCount());
 
   queue_.DelayedRemove(id1);
-  EXPECT_EQ(1, queue_.GetCount());
+  EXPECT_EQ(1u, queue_.GetCount());
 
   Cleanup(base::TimeDelta::FromMinutes(1));
-  EXPECT_EQ(1, queue_.GetCount());
+  EXPECT_EQ(1u, queue_.GetCount());
 
   Cleanup(base::TimeDelta::FromMinutes(15));
-  EXPECT_EQ(0, queue_.GetCount());
+  EXPECT_EQ(0u, queue_.GetCount());
 }
 
 TEST_F(CommandQueueTest, Dispatch) {
diff --git a/src/commands/object_schema.cc b/src/commands/object_schema.cc
index b70beff..6cfa5f4 100644
--- a/src/commands/object_schema.cc
+++ b/src/commands/object_schema.cc
@@ -283,7 +283,8 @@
 std::unique_ptr<ObjectSchema> ObjectSchema::Clone() const {
   std::unique_ptr<ObjectSchema> cloned{new ObjectSchema};
   for (const auto& pair : properties_) {
-    cloned->properties_.emplace(pair.first, pair.second->Clone());
+    cloned->properties_.insert(
+        std::make_pair(pair.first, pair.second->Clone()));
   }
   cloned->extra_properties_allowed_ = extra_properties_allowed_;
   return cloned;
@@ -335,7 +336,7 @@
         object_schema ? object_schema->GetProp(iter.key()) : nullptr;
     auto prop_type = PropFromJson(iter.value(), base_schema, error);
     if (prop_type) {
-      properties.emplace(iter.key(), std::move(prop_type));
+      properties.insert(std::make_pair(iter.key(), std::move(prop_type)));
     } else {
       Error::AddToPrintf(error, FROM_HERE, errors::commands::kDomain,
                          errors::commands::kInvalidPropDef,
diff --git a/src/commands/object_schema_unittest.cc b/src/commands/object_schema_unittest.cc
index 6417952..7cdc16d 100644
--- a/src/commands/object_schema_unittest.cc
+++ b/src/commands/object_schema_unittest.cc
@@ -1664,7 +1664,7 @@
   value = prop.CreatePropValue(*CreateDictionaryValue(val_json).get(), nullptr);
   ASSERT_NE(nullptr, value);
   obj = value->GetObject()->GetValue();
-  EXPECT_EQ(3, obj.size());
+  EXPECT_EQ(3u, obj.size());
 
   EXPECT_EQ(100, obj["param1"]->GetInt()->GetValue());
   EXPECT_EQ(obj.end(), obj.find("param2"));
diff --git a/src/commands/prop_types.cc b/src/commands/prop_types.cc
index 88a53bd..def68b1 100644
--- a/src/commands/prop_types.cc
+++ b/src/commands/prop_types.cc
@@ -110,7 +110,8 @@
   auto cloned = PropType::Create(GetType());
   cloned->based_on_schema_ = based_on_schema_;
   for (const auto& pair : constraints_) {
-    cloned->constraints_.emplace(pair.first, pair.second->Clone());
+    cloned->constraints_.insert(
+        std::make_pair(pair.first, pair.second->Clone()));
   }
   cloned->default_.is_inherited = default_.is_inherited;
   if (default_.value)
@@ -143,7 +144,8 @@
     return false;
   if (base_schema) {
     for (const auto& pair : base_schema->GetConstraints()) {
-      constraints_.emplace(pair.first, pair.second->CloneAsInherited());
+      constraints_.insert(
+          std::make_pair(pair.first, pair.second->CloneAsInherited()));
     }
   }
   if (!ConstraintsFromJson(value, &processed_keys, error))
diff --git a/src/commands/prop_values.h b/src/commands/prop_values.h
index f0a401e..960802b 100644
--- a/src/commands/prop_values.h
+++ b/src/commands/prop_values.h
@@ -130,7 +130,7 @@
 template <typename T>
 class TypedValueBase : public PropValue {
  public:
-  using PropValue::PropValue;
+  TypedValueBase(const PropType& type) : PropValue(type) {}
 
   // Overrides from PropValue base class.
   ValueType GetType() const override { return GetValueType<T>(); }
@@ -164,11 +164,9 @@
 template <typename Derived, typename T>
 class TypedValueWithClone : public TypedValueBase<T> {
  public:
-  using Base = TypedValueWithClone<Derived, T>;
-
-  // Expose the custom constructor of the base class.
-  using TypedValueBase<T>::TypedValueBase;
-  using PropValue::GetPropType;
+  TypedValueWithClone(const PropType& type) : TypedValueBase<T>(type) {}
+  TypedValueWithClone(const PropType& type, const T& value)
+      : TypedValueBase<T>(type, value) {}
 
   std::unique_ptr<PropValue> Clone() const override {
     return std::unique_ptr<PropValue>{
@@ -183,7 +181,7 @@
       return nullptr;
 
     // Only place where invalid value can exist.
-    std::unique_ptr<Derived> result{new Derived{type, tmp_value}};
+    std::unique_ptr<Derived> result(new Derived(type, tmp_value));
     if (!result->GetPropType()->ValidateConstraints(*result, error))
       return nullptr;
 
@@ -194,8 +192,11 @@
 // Value of type Integer.
 class IntValue final : public TypedValueWithClone<IntValue, int> {
  public:
-  using Base::Base;
-  friend class TypedValueWithClone<IntValue, int>;
+  explicit IntValue(const PropType& type)
+      : TypedValueWithClone<IntValue, int>(type) {}
+  IntValue(const PropType& type, int value)
+      : TypedValueWithClone<IntValue, int>(type, value) {}
+
   IntValue* GetInt() override { return this; }
   IntValue const* GetInt() const override { return this; }
 };
@@ -203,8 +204,11 @@
 // Value of type Number.
 class DoubleValue final : public TypedValueWithClone<DoubleValue, double> {
  public:
-  using Base::Base;
-  friend class TypedValueWithClone<DoubleValue, double>;
+  explicit DoubleValue(const PropType& type)
+      : TypedValueWithClone<DoubleValue, double>(type) {}
+  DoubleValue(const PropType& type, double value)
+      : TypedValueWithClone<DoubleValue, double>(type, value) {}
+
   DoubleValue* GetDouble() override { return this; }
   DoubleValue const* GetDouble() const override { return this; }
 };
@@ -212,8 +216,11 @@
 // Value of type String.
 class StringValue final : public TypedValueWithClone<StringValue, std::string> {
  public:
-  using Base::Base;
-  friend class TypedValueWithClone<StringValue, std::string>;
+  explicit StringValue(const PropType& type)
+      : TypedValueWithClone<StringValue, std::string>(type) {}
+  StringValue(const PropType& type, std::string value)
+      : TypedValueWithClone<StringValue, std::string>(type, value) {}
+
   StringValue* GetString() override { return this; }
   StringValue const* GetString() const override { return this; }
 };
@@ -221,8 +228,11 @@
 // Value of type Boolean.
 class BooleanValue final : public TypedValueWithClone<BooleanValue, bool> {
  public:
-  using Base::Base;
-  friend class TypedValueWithClone<BooleanValue, bool>;
+  explicit BooleanValue(const PropType& type)
+      : TypedValueWithClone<BooleanValue, bool>(type) {}
+  BooleanValue(const PropType& type, bool value)
+      : TypedValueWithClone<BooleanValue, bool>(type, value) {}
+
   BooleanValue* GetBoolean() override { return this; }
   BooleanValue const* GetBoolean() const override { return this; }
 };
@@ -230,8 +240,11 @@
 // Value of type Object.
 class ObjectValue final : public TypedValueWithClone<ObjectValue, ValueMap> {
  public:
-  using Base::Base;
-  friend class TypedValueWithClone<ObjectValue, ValueMap>;
+  explicit ObjectValue(const PropType& type)
+      : TypedValueWithClone<ObjectValue, ValueMap>(type) {}
+  ObjectValue(const PropType& type, ValueMap value)
+      : TypedValueWithClone<ObjectValue, ValueMap>(type, value) {}
+
   ObjectValue* GetObject() override { return this; }
   ObjectValue const* GetObject() const override { return this; }
 };
@@ -239,8 +252,11 @@
 // Value of type Array.
 class ArrayValue final : public TypedValueWithClone<ArrayValue, ValueVector> {
  public:
-  using Base::Base;
-  friend class TypedValueWithClone<ArrayValue, ValueVector>;
+  explicit ArrayValue(const PropType& type)
+      : TypedValueWithClone<ArrayValue, ValueVector>(type) {}
+  ArrayValue(const PropType& type, ValueVector value)
+      : TypedValueWithClone<ArrayValue, ValueVector>(type, value) {}
+
   ArrayValue* GetArray() override { return this; }
   ArrayValue const* GetArray() const override { return this; }
 };
diff --git a/src/commands/schema_utils.cc b/src/commands/schema_utils.cc
index 3c3e949..be6cb16 100644
--- a/src/commands/schema_utils.cc
+++ b/src/commands/schema_utils.cc
@@ -155,10 +155,10 @@
                            pair.first.c_str());
         return false;
       }
-      value_out->emplace_hint(value_out->end(), pair.first, std::move(value));
+      value_out->insert(std::make_pair(pair.first, std::move(value)));
       keys_processed.insert(pair.first);
     } else if (def_value) {
-      value_out->emplace_hint(value_out->end(), pair.first, def_value->Clone());
+      value_out->insert(std::make_pair(pair.first, def_value->Clone()));
       keys_processed.insert(pair.first);
     } else if (pair.second->IsRequired()) {
       return ErrorMissingProperty(error, FROM_HERE, pair.first.c_str());
diff --git a/src/config.cc b/src/config.cc
index 52f5ea1..fe50e3b 100644
--- a/src/config.cc
+++ b/src/config.cc
@@ -65,7 +65,7 @@
   result.oauth_url = "https://accounts.google.com/o/oauth2/";
   result.service_url = kWeaveUrl;
   result.local_anonymous_access_role = AuthScope::kViewer;
-  result.pairing_modes.emplace(PairingType::kPinCode);
+  result.pairing_modes.insert(PairingType::kPinCode);
   result.device_id = base::GenerateGUID();
   return result;
 }
diff --git a/src/data_encoding_unittest.cc b/src/data_encoding_unittest.cc
index 7e3bfe4..53dc534 100644
--- a/src/data_encoding_unittest.cc
+++ b/src/data_encoding_unittest.cc
@@ -30,7 +30,7 @@
   EXPECT_EQ("q=test&path=%2Fusr%2Fbin&%23=%25", encoded);
 
   auto params = WebParamsDecode(encoded);
-  EXPECT_EQ(3, params.size());
+  EXPECT_EQ(3u, params.size());
   EXPECT_EQ("q", params[0].first);
   EXPECT_EQ("test", params[0].second);
   EXPECT_EQ("path", params[1].first);
diff --git a/src/notification/xmpp_iq_stanza_handler.cc b/src/notification/xmpp_iq_stanza_handler.cc
index 8753030..9ac4223 100644
--- a/src/notification/xmpp_iq_stanza_handler.cc
+++ b/src/notification/xmpp_iq_stanza_handler.cc
@@ -72,7 +72,7 @@
     const ResponseCallback& response_callback,
     const TimeoutCallback& timeout_callback) {
   // Remember the response callback to call later.
-  requests_.emplace(++last_request_id_, response_callback);
+  requests_.insert(std::make_pair(++last_request_id_, response_callback));
   // Schedule a time-out callback for this request.
   if (timeout < base::TimeDelta::Max()) {
     task_runner_->PostDelayedTask(
diff --git a/src/notification/xmpp_stream_parser.cc b/src/notification/xmpp_stream_parser.cc
index de3b8f1..9efaeb5 100644
--- a/src/notification/xmpp_stream_parser.cc
+++ b/src/notification/xmpp_stream_parser.cc
@@ -36,7 +36,7 @@
   std::map<std::string, std::string> attributes;
   if (attr != nullptr) {
     for (size_t n = 0; attr[n] != nullptr && attr[n + 1] != nullptr; n += 2) {
-      attributes.emplace(attr[n], attr[n + 1]);
+      attributes.insert(std::make_pair(attr[n], attr[n + 1]));
     }
   }
   self->OnOpenElement(element, std::move(attributes));
diff --git a/src/privet/cloud_delegate.cc b/src/privet/cloud_delegate.cc
index 32ebf48..efb69bd 100644
--- a/src/privet/cloud_delegate.cc
+++ b/src/privet/cloud_delegate.cc
@@ -213,7 +213,7 @@
  private:
   void OnCommandAdded(Command* command) {
     // Set to 0 for any new unknown command.
-    command_owners_.emplace(command->GetID(), 0);
+    command_owners_.insert(std::make_pair(command->GetID(), 0));
   }
 
   void OnCommandRemoved(Command* command) {
diff --git a/src/privet/privet_handler.cc b/src/privet/privet_handler.cc
index 157c982..157feed 100644
--- a/src/privet/privet_handler.cc
+++ b/src/privet/privet_handler.cc
@@ -469,7 +469,7 @@
   params.handler = handler;
   params.scope = scope;
   params.https_only = false;
-  CHECK(handlers_.emplace(path, params).second);
+  CHECK(handlers_.insert(std::make_pair(path, params)).second);
 }
 
 void PrivetHandler::AddSecureHandler(const std::string& path,
@@ -479,7 +479,7 @@
   params.handler = handler;
   params.scope = scope;
   params.https_only = true;
-  CHECK(handlers_.emplace(path, params).second);
+  CHECK(handlers_.insert(std::make_pair(path, params)).second);
 }
 
 void PrivetHandler::HandleInfo(const base::DictionaryValue&,
diff --git a/src/privet/security_manager.cc b/src/privet/security_manager.cc
index 1b4e3c5..19e8c18 100644
--- a/src/privet/security_manager.cc
+++ b/src/privet/security_manager.cc
@@ -258,7 +258,7 @@
   } while (confirmed_sessions_.find(session) != confirmed_sessions_.end() ||
            pending_sessions_.find(session) != pending_sessions_.end());
   std::string commitment = spake->GetMessage();
-  pending_sessions_.emplace(session, std::move(spake));
+  pending_sessions_.insert(std::make_pair(session, std::move(spake)));
 
   task_runner_->PostDelayedTask(
       FROM_HERE,
@@ -317,7 +317,8 @@
   std::vector<uint8_t> cert_hmac = HmacSha256(
       std::vector<uint8_t>(key.begin(), key.end()), certificate_fingerprint_);
   *signature = Base64Encode(cert_hmac);
-  confirmed_sessions_.emplace(session->first, std::move(session->second));
+  confirmed_sessions_.insert(
+      std::make_pair(session->first, std::move(session->second)));
   task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(&SecurityManager::CloseConfirmedSession),
diff --git a/src/privet/security_manager_unittest.cc b/src/privet/security_manager_unittest.cc
index 7229710..0880b14 100644
--- a/src/privet/security_manager_unittest.cc
+++ b/src/privet/security_manager_unittest.cc
@@ -109,7 +109,7 @@
 };
 
 TEST_F(SecurityManagerTest, RandomSecret) {
-  EXPECT_GE(security_.GetSecret().size(), 32);
+  EXPECT_GE(security_.GetSecret().size(), 32u);
   EXPECT_TRUE(IsBase64(security_.GetSecret()));
 }
 
diff --git a/src/privet/wifi_ssid_generator_unittest.cc b/src/privet/wifi_ssid_generator_unittest.cc
index 398e105..10680c8 100644
--- a/src/privet/wifi_ssid_generator_unittest.cc
+++ b/src/privet/wifi_ssid_generator_unittest.cc
@@ -23,7 +23,7 @@
 };
 
 TEST_F(WifiSsidGeneratorTest, GenerateFlagsNoHostedAp) {
-  EXPECT_EQ(ssid_generator_.GenerateFlags().size(), 2);
+  EXPECT_EQ(ssid_generator_.GenerateFlags().size(), 2u);
 
   wifi_.connection_state_ = ConnectionState{ConnectionState::kUnconfigured};
   gcd_.connection_state_ = ConnectionState{ConnectionState::kUnconfigured};
@@ -42,7 +42,7 @@
 TEST_F(WifiSsidGeneratorTest, GenerateFlagsWithHostedAp) {
   EXPECT_CALL(wifi_, GetHostedSsid())
       .WillRepeatedly(Return(ssid_generator_.GenerateSsid()));
-  EXPECT_EQ(ssid_generator_.GenerateFlags().size(), 2);
+  EXPECT_EQ(ssid_generator_.GenerateFlags().size(), 2u);
 
   wifi_.connection_state_ = ConnectionState{ConnectionState::kUnconfigured};
   gcd_.connection_state_ = ConnectionState{ConnectionState::kUnconfigured};
@@ -59,7 +59,7 @@
 }
 
 TEST_F(WifiSsidGeneratorTest, GenerateSsid31orLess) {
-  EXPECT_LE(ssid_generator_.GenerateSsid().size(), 31);
+  EXPECT_LE(ssid_generator_.GenerateSsid().size(), 31u);
 }
 
 TEST_F(WifiSsidGeneratorTest, GenerateSsidValue) {
diff --git a/src/states/state_change_queue_unittest.cc b/src/states/state_change_queue_unittest.cc
index 5fbc012..865336c 100644
--- a/src/states/state_change_queue_unittest.cc
+++ b/src/states/state_change_queue_unittest.cc
@@ -24,7 +24,7 @@
 
 TEST_F(StateChangeQueueTest, Empty) {
   EXPECT_TRUE(queue_->IsEmpty());
-  EXPECT_EQ(0, queue_->GetLastStateChangeId());
+  EXPECT_EQ(0u, queue_->GetLastStateChangeId());
   EXPECT_TRUE(queue_->GetAndClearRecordedStateChanges().empty());
 }
 
@@ -33,10 +33,10 @@
   ASSERT_TRUE(queue_->NotifyPropertiesUpdated(
       timestamp, CreateDictionaryValue("{'prop': {'name': 23}}")));
   EXPECT_FALSE(queue_->IsEmpty());
-  EXPECT_EQ(1, queue_->GetLastStateChangeId());
+  EXPECT_EQ(1u, queue_->GetLastStateChangeId());
   auto changes = queue_->GetAndClearRecordedStateChanges();
-  EXPECT_EQ(1, queue_->GetLastStateChangeId());
-  ASSERT_EQ(1, changes.size());
+  EXPECT_EQ(1u, queue_->GetLastStateChangeId());
+  ASSERT_EQ(1u, changes.size());
   EXPECT_EQ(timestamp, changes.front().timestamp);
   EXPECT_JSON_EQ("{'prop':{'name': 23}}", *changes.front().changed_properties);
   EXPECT_TRUE(queue_->IsEmpty());
@@ -54,10 +54,10 @@
   ASSERT_TRUE(queue_->NotifyPropertiesUpdated(
       timestamp2, CreateDictionaryValue(state2)));
 
-  EXPECT_EQ(2, queue_->GetLastStateChangeId());
+  EXPECT_EQ(2u, queue_->GetLastStateChangeId());
   EXPECT_FALSE(queue_->IsEmpty());
   auto changes = queue_->GetAndClearRecordedStateChanges();
-  ASSERT_EQ(2, changes.size());
+  ASSERT_EQ(2u, changes.size());
   EXPECT_EQ(timestamp1, changes[0].timestamp);
   EXPECT_JSON_EQ(state1, *changes[0].changed_properties);
   EXPECT_EQ(timestamp2, changes[1].timestamp);
@@ -83,8 +83,8 @@
       timestamp + time_delta, CreateDictionaryValue("{'prop': {'name1': 4}}")));
 
   auto changes = queue_->GetAndClearRecordedStateChanges();
-  EXPECT_EQ(4, queue_->GetLastStateChangeId());
-  ASSERT_EQ(2, changes.size());
+  EXPECT_EQ(4u, queue_->GetLastStateChangeId());
+  ASSERT_EQ(2u, changes.size());
 
   const std::string expected1 = "{'prop': {'name1': 3, 'name2': 2}}";
   const std::string expected2 = "{'prop': {'name1': 4}}";
@@ -111,9 +111,9 @@
       start_time + time_delta2,
       CreateDictionaryValue("{'prop': {'name10': 10, 'name11': 11}}")));
 
-  EXPECT_EQ(3, queue_->GetLastStateChangeId());
+  EXPECT_EQ(3u, queue_->GetLastStateChangeId());
   auto changes = queue_->GetAndClearRecordedStateChanges();
-  ASSERT_EQ(2, changes.size());
+  ASSERT_EQ(2u, changes.size());
 
   const std::string expected1 =
       "{'prop': {'name1': 3, 'name2': 2, 'name3': 4}}";
diff --git a/src/states/state_manager.cc b/src/states/state_manager.cc
index a424588..b1e70a3 100644
--- a/src/states/state_manager.cc
+++ b/src/states/state_manager.cc
@@ -218,8 +218,9 @@
   StatePackage* package = FindPackage(package_name);
   if (package == nullptr) {
     std::unique_ptr<StatePackage> new_package{new StatePackage(package_name)};
-    package = packages_.emplace(package_name, std::move(new_package))
-                  .first->second.get();
+    package =
+        packages_.insert(std::make_pair(package_name, std::move(new_package)))
+            .first->second.get();
   }
   return package;
 }
diff --git a/src/states/state_manager_unittest.cc b/src/states/state_manager_unittest.cc
index 933e11b..f336d42 100644
--- a/src/states/state_manager_unittest.cc
+++ b/src/states/state_manager_unittest.cc
@@ -237,7 +237,7 @@
   EXPECT_CALL(mock_state_change_queue_, GetLastStateChangeId())
       .WillOnce(Return(0));
   auto changes = mgr_->GetAndClearRecordedStateChanges();
-  ASSERT_EQ(1, changes.second.size());
+  ASSERT_EQ(1u, changes.second.size());
   EXPECT_EQ(timestamp_, changes.second.back().timestamp);
   EXPECT_JSON_EQ(expected_val, *changes.second.back().changed_properties);
 }
diff --git a/src/states/state_package_unittest.cc b/src/states/state_package_unittest.cc
index 5e1b933..0da005b 100644
--- a/src/states/state_package_unittest.cc
+++ b/src/states/state_package_unittest.cc
@@ -100,8 +100,8 @@
 TEST(StatePackage, AddSchemaFromJson_OnEmpty) {
   StatePackage package("test");
   ASSERT_TRUE(package.AddSchemaFromJson(GetTestSchema().get(), nullptr));
-  EXPECT_EQ(4, GetTypes(package).size());
-  EXPECT_EQ(0, GetValues(package).size());
+  EXPECT_EQ(4u, GetTypes(package).size());
+  EXPECT_EQ(0u, GetValues(package).size());
 
   auto expected = R"({
     'color': {
@@ -138,7 +138,7 @@
   StatePackage package("test");
   ASSERT_TRUE(package.AddSchemaFromJson(GetTestSchema().get(), nullptr));
   ASSERT_TRUE(package.AddValuesFromJson(GetTestValues().get(), nullptr));
-  EXPECT_EQ(4, GetValues(package).size());
+  EXPECT_EQ(4u, GetValues(package).size());
   auto expected = R"({
     'color': 'white',
     'direction': {
@@ -157,8 +157,8 @@
       'type': 'string'
     }})");
   ASSERT_TRUE(package_->AddSchemaFromJson(dict.get(), nullptr));
-  EXPECT_EQ(5, GetTypes(*package_).size());
-  EXPECT_EQ(4, GetValues(*package_).size());
+  EXPECT_EQ(5u, GetTypes(*package_).size());
+  EXPECT_EQ(4u, GetValues(*package_).size());
   auto expected = R"({
     'brightness': {
       'enum': ['low', 'medium', 'high'],
@@ -211,7 +211,7 @@
   ASSERT_TRUE(package_->AddSchemaFromJson(dict.get(), nullptr));
   dict = CreateDictionaryValue("{'brightness':'medium'}");
   ASSERT_TRUE(package_->AddValuesFromJson(dict.get(), nullptr));
-  EXPECT_EQ(5, GetValues(*package_).size());
+  EXPECT_EQ(5u, GetValues(*package_).size());
   auto expected = R"({
     'brightness': 'medium',
     'color': 'white',
diff --git a/src/string_utils_unittest.cc b/src/string_utils_unittest.cc
index c26d7d8..3966921 100644
--- a/src/string_utils_unittest.cc
+++ b/src/string_utils_unittest.cc
@@ -17,21 +17,21 @@
   std::vector<std::string> parts;
 
   parts = Split("", ",", false, false);
-  EXPECT_EQ(0, parts.size());
+  EXPECT_EQ(0u, parts.size());
 
   parts = Split("abc", ",", false, false);
-  EXPECT_EQ(1, parts.size());
+  EXPECT_EQ(1u, parts.size());
   EXPECT_EQ("abc", parts[0]);
 
   parts = Split(",a,bc , d,  ,e, ", ",", true, true);
-  EXPECT_EQ(4, parts.size());
+  EXPECT_EQ(4u, parts.size());
   EXPECT_EQ("a", parts[0]);
   EXPECT_EQ("bc", parts[1]);
   EXPECT_EQ("d", parts[2]);
   EXPECT_EQ("e", parts[3]);
 
   parts = Split(",a,bc , d,  ,e, ", ",", false, true);
-  EXPECT_EQ(6, parts.size());
+  EXPECT_EQ(6u, parts.size());
   EXPECT_EQ("a", parts[0]);
   EXPECT_EQ("bc ", parts[1]);
   EXPECT_EQ(" d", parts[2]);
@@ -40,7 +40,7 @@
   EXPECT_EQ(" ", parts[5]);
 
   parts = Split(",a,bc , d,  ,e, ", ",", true, false);
-  EXPECT_EQ(7, parts.size());
+  EXPECT_EQ(7u, parts.size());
   EXPECT_EQ("", parts[0]);
   EXPECT_EQ("a", parts[1]);
   EXPECT_EQ("bc", parts[2]);
@@ -50,7 +50,7 @@
   EXPECT_EQ("", parts[6]);
 
   parts = Split(",a,bc , d,  ,e, ", ",", false, false);
-  EXPECT_EQ(7, parts.size());
+  EXPECT_EQ(7u, parts.size());
   EXPECT_EQ("", parts[0]);
   EXPECT_EQ("a", parts[1]);
   EXPECT_EQ("bc ", parts[2]);
@@ -60,12 +60,12 @@
   EXPECT_EQ(" ", parts[6]);
 
   parts = Split("abc:=xyz", ":=", false, false);
-  EXPECT_EQ(2, parts.size());
+  EXPECT_EQ(2u, parts.size());
   EXPECT_EQ("abc", parts[0]);
   EXPECT_EQ("xyz", parts[1]);
 
   parts = Split("abc", "", false, false);
-  EXPECT_EQ(3, parts.size());
+  EXPECT_EQ(3u, parts.size());
   EXPECT_EQ("a", parts[0]);
   EXPECT_EQ("b", parts[1]);
   EXPECT_EQ("c", parts[2]);