diff --git a/shill/device.cc b/shill/device.cc
index 8fefc1f..b279e6a 100644
--- a/shill/device.cc
+++ b/shill/device.cc
@@ -484,15 +484,18 @@
     addresses_str.push_back(address_str);
   }
 
-  // Setup timer to monitor DNS server lifetime if not infinite lifetime.
-  if (lifetime != ND_OPT_LIFETIME_INFINITY) {
-    StartIPv6DNSServerTimer(lifetime);
-  }
-
   if (!ip6config_) {
     ip6config_ = new IPConfig(control_interface_, link_name_);
   }
 
+  if (lifetime != ND_OPT_LIFETIME_INFINITY) {
+    // Setup timer to monitor DNS server lifetime if not infinite lifetime.
+    StartIPv6DNSServerTimer(lifetime);
+    ip6config_->UpdateLeaseExpirationTime(lifetime);
+  } else {
+    ip6config_->ResetLeaseExpirationTime();
+  }
+
   // Done if no change in server addresses.
   if (ip6config_->properties().dns_servers == addresses_str) {
     SLOG(Device, 2) << __func__ << " IPv6 DNS server list for "
diff --git a/shill/device.h b/shill/device.h
index 8902983..b18f232 100644
--- a/shill/device.h
+++ b/shill/device.h
@@ -324,6 +324,8 @@
   FRIEND_TEST(DeviceTest, OnIPv6AddressChanged);
   FRIEND_TEST(DeviceTest, OnIPv6ConfigurationCompleted);
   FRIEND_TEST(DeviceTest, OnIPv6DnsServerAddressesChanged);
+  FRIEND_TEST(DeviceTest,
+              OnIPv6DnsServerAddressesChanged_LeaseExpirationUpdated);
   FRIEND_TEST(DeviceTest, Save);
   FRIEND_TEST(DeviceTest, SelectedService);
   FRIEND_TEST(DeviceTest, SetEnabledNonPersistent);
diff --git a/shill/device_unittest.cc b/shill/device_unittest.cc
index 6e0599d..58a2e0a 100644
--- a/shill/device_unittest.cc
+++ b/shill/device_unittest.cc
@@ -48,6 +48,7 @@
 #include "shill/mock_store.h"
 #include "shill/mock_time.h"
 #include "shill/mock_traffic_monitor.h"
+#include "shill/ndisc.h"
 #include "shill/portal_detector.h"
 #include "shill/property_store_unittest.h"
 #include "shill/static_ip_parameters.h"
@@ -1029,6 +1030,41 @@
   Mock::VerifyAndClearExpectations(&device_info_);
 }
 
+TEST_F(DeviceTest, OnIPv6DnsServerAddressesChanged_LeaseExpirationUpdated) {
+  MockManager manager(control_interface(),
+                                  dispatcher(),
+                                  metrics(),
+                                  glib());
+  manager.set_mock_device_info(&device_info_);
+  SetManager(&manager);
+
+  scoped_refptr<MockIPConfig> ip6config =
+      new MockIPConfig(control_interface(), kDeviceName);
+  device_->ip6config_ = ip6config;
+
+  // Non-infinite lifetime should trigger an update of the current lease
+  // expiration time.
+  const uint32 kExpiredLifetime = 1;
+  EXPECT_CALL(device_info_,
+              GetIPv6DnsServerAddresses(kDeviceInterfaceIndex, _, _))
+      .WillOnce(DoAll(SetArgPointee<2>(kExpiredLifetime),
+                      Return(true)));
+  EXPECT_CALL(*ip6config, UpdateLeaseExpirationTime(_)).Times(1);
+  EXPECT_CALL(*ip6config, ResetLeaseExpirationTime()).Times(0);
+  device_->OnIPv6DnsServerAddressesChanged();
+
+  // Infinite lifetime should cause a reset of the current lease expiration
+  // time to its default value.
+  const uint32 kExpiredLifetimeInfinity = ND_OPT_LIFETIME_INFINITY;
+  EXPECT_CALL(device_info_,
+              GetIPv6DnsServerAddresses(kDeviceInterfaceIndex, _, _))
+      .WillOnce(DoAll(SetArgPointee<2>(kExpiredLifetimeInfinity),
+                      Return(true)));
+  EXPECT_CALL(*ip6config, UpdateLeaseExpirationTime(_)).Times(0);
+  EXPECT_CALL(*ip6config, ResetLeaseExpirationTime()).Times(1);
+  device_->OnIPv6DnsServerAddressesChanged();
+}
+
 TEST_F(DeviceTest, OnIPv6DnsServerAddressesChanged) {
   StrictMock<MockManager> manager(control_interface(),
                                   dispatcher(),
diff --git a/shill/dhcp_config.cc b/shill/dhcp_config.cc
index ecd479d..0bcb5fa 100644
--- a/shill/dhcp_config.cc
+++ b/shill/dhcp_config.cc
@@ -267,9 +267,11 @@
 void DHCPConfig::UpdateProperties(const Properties &properties) {
   StopAcquisitionTimeout();
   if (properties.lease_duration_seconds) {
+    UpdateLeaseExpirationTime(properties.lease_duration_seconds);
     StartExpirationTimeout(properties.lease_duration_seconds);
   } else {
     LOG(WARNING) << "Lease duration is zero; not starting an expiration timer.";
+    ResetLeaseExpirationTime();
     StopExpirationTimeout();
   }
   IPConfig::UpdateProperties(properties);
diff --git a/shill/ipconfig.cc b/shill/ipconfig.cc
index 1f64df1..7af79c0 100644
--- a/shill/ipconfig.cc
+++ b/shill/ipconfig.cc
@@ -4,12 +4,15 @@
 
 #include "shill/ipconfig.h"
 
+#include <sys/time.h>
+
 #include <chromeos/dbus/service_constants.h>
 
 #include "shill/adaptor_interfaces.h"
 #include "shill/control_interface.h"
 #include "shill/error.h"
 #include "shill/logging.h"
+#include "shill/shill_time.h"
 #include "shill/static_ip_parameters.h"
 
 using base::Callback;
@@ -17,8 +20,15 @@
 
 namespace shill {
 
+namespace {
+
+const time_t kDefaultLeaseExpirationTime = LONG_MAX;
+
+}  // namespace
+
 // static
 const char IPConfig::kType[] = "ip";
+
 // static
 uint IPConfig::global_serial_ = 0;
 
@@ -58,6 +68,8 @@
                              &properties_.vendor_encapsulated_options);
   store_.RegisterConstString(kWebProxyAutoDiscoveryUrlProperty,
                              &properties_.web_proxy_auto_discovery);
+  time_ = Time::GetInstance();
+  current_lease_expiration_time_ = {kDefaultLeaseExpirationTime, 0};
   SLOG(Inet, 2) << __func__ << " device: " << device_name();
 }
 
@@ -100,6 +112,34 @@
   EmitChanges();
 }
 
+void IPConfig::UpdateLeaseExpirationTime(uint32_t new_lease_duration) {
+  struct timeval new_expiration_time;
+  time_->GetTimeBoottime(&new_expiration_time);
+  new_expiration_time.tv_sec += new_lease_duration;
+  current_lease_expiration_time_ = new_expiration_time;
+}
+
+void IPConfig::ResetLeaseExpirationTime() {
+  current_lease_expiration_time_ = {kDefaultLeaseExpirationTime, 0};
+}
+
+bool IPConfig::TimeToLeaseExpiry(uint32_t *time_left) {
+  if (current_lease_expiration_time_.tv_sec == kDefaultLeaseExpirationTime) {
+    LOG(ERROR) << __func__ << ": "
+               << "No current DHCP lease";
+    return false;
+  }
+  struct timeval now;
+  time_->GetTimeBoottime(&now);
+  if (now.tv_sec > current_lease_expiration_time_.tv_sec) {
+    LOG(ERROR) << __func__ << ": "
+               << "Current DHCP lease has already expired";
+    return false;
+  }
+  *time_left = current_lease_expiration_time_.tv_sec - now.tv_sec;
+  return true;
+}
+
 void IPConfig::UpdateProperties(const Properties &properties) {
   // Take a reference of this instance to make sure we don't get destroyed in
   // the middle of this call. (The |update_callback_| may cause a reference
diff --git a/shill/ipconfig.h b/shill/ipconfig.h
index 97ecff8..cda8bcd 100644
--- a/shill/ipconfig.h
+++ b/shill/ipconfig.h
@@ -7,6 +7,7 @@
 
 #include <memory>
 #include <string>
+#include <sys/time.h>
 #include <vector>
 
 #include <base/callback.h>
@@ -23,6 +24,7 @@
 class Error;
 class IPConfigAdaptorInterface;
 class StaticIPParameters;
+class Time;
 
 // IPConfig superclass. Individual IP configuration types will inherit from this
 // class.
@@ -152,6 +154,18 @@
   // static IP parameters were previously applied.
   void RestoreSavedIPParameters(StaticIPParameters *static_ip_parameters);
 
+  // Updates |current_lease_expiration_time_| by adding |new_lease_duration| to
+  // the current time.
+  virtual void UpdateLeaseExpirationTime(uint32_t new_lease_duration);
+
+  // Resets |current_lease_expiration_time_| to its default value.
+  virtual void ResetLeaseExpirationTime();
+
+  // Returns the time left (in seconds) till the current DHCP lease is to be
+  // renewed in |time_left|. Returns false if an error occurs (i.e. current
+  // lease has already expired or no current DHCP lease), true otherwise.
+  bool TimeToLeaseExpiry(uint32_t *time_left);
+
  protected:
   // Inform RPC listeners of changes to our properties. MAY emit
   // changes even on unchanged properties.
@@ -178,6 +192,10 @@
   FRIEND_TEST(DeviceTest, OnIPConfigExpired);
   FRIEND_TEST(IPConfigTest, UpdateCallback);
   FRIEND_TEST(IPConfigTest, UpdateProperties);
+  FRIEND_TEST(IPConfigTest, UpdateLeaseExpirationTime);
+  FRIEND_TEST(IPConfigTest, TimeToLeaseExpiry_NoDHCPLease);
+  FRIEND_TEST(IPConfigTest, TimeToLeaseExpiry_CurrentLeaseExpired);
+  FRIEND_TEST(IPConfigTest, TimeToLeaseExpiry_Success);
   FRIEND_TEST(ResolverTest, Empty);
   FRIEND_TEST(ResolverTest, NonEmpty);
   FRIEND_TEST(RoutingTableTest, ConfigureRoutes);
@@ -199,6 +217,8 @@
   Callback failure_callback_;
   Callback refresh_callback_;
   Callback expire_callback_;
+  struct timeval current_lease_expiration_time_;
+  Time *time_;
 
   DISALLOW_COPY_AND_ASSIGN(IPConfig);
 };
diff --git a/shill/ipconfig_unittest.cc b/shill/ipconfig_unittest.cc
index 31b5248..0aa4469 100644
--- a/shill/ipconfig_unittest.cc
+++ b/shill/ipconfig_unittest.cc
@@ -4,23 +4,31 @@
 
 #include "shill/ipconfig.h"
 
+#include <sys/time.h>
+
 #include <base/bind.h>
 #include <chromeos/dbus/service_constants.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include "shill/logging.h"
 #include "shill/mock_adaptors.h"
 #include "shill/mock_control.h"
+#include "shill/mock_log.h"
 #include "shill/mock_store.h"
+#include "shill/mock_time.h"
 #include "shill/static_ip_parameters.h"
 
 using base::Bind;
 using base::Unretained;
 using std::string;
 using testing::_;
+using testing::EndsWith;
+using testing::DoAll;
 using testing::Mock;
 using testing::Return;
 using testing::SaveArg;
+using testing::SetArgPointee;
 using testing::SetArgumentPointee;
 using testing::StrictMock;
 using testing::Test;
@@ -29,11 +37,14 @@
 
 namespace {
 const char kDeviceName[] = "testdevice";
+const uint32_t kTimeNow = 10;
 }  // namespace
 
 class IPConfigTest : public Test {
  public:
-  IPConfigTest() : ipconfig_(new IPConfig(&control_, kDeviceName)) {}
+  IPConfigTest() : ipconfig_(new IPConfig(&control_, kDeviceName)) {
+    ipconfig_->time_ = &time_;
+  }
   void DropRef(const IPConfigRefPtr &/*ipconfig*/) {
     ipconfig_ = nullptr;
   }
@@ -90,6 +101,7 @@
   }
 
   MockControl control_;
+  MockTime time_;
   IPConfigRefPtr ipconfig_;
 };
 
@@ -226,4 +238,53 @@
   Mock::VerifyAndClearExpectations(adaptor);
 }
 
+TEST_F(IPConfigTest, UpdateLeaseExpirationTime) {
+  const struct timeval expected_time_now = {kTimeNow , 0};
+  uint32_t lease_duration = 1;
+  EXPECT_CALL(time_, GetTimeBoottime(_))
+      .WillOnce(DoAll(SetArgPointee<0>(expected_time_now), Return(0)));
+  ipconfig_->UpdateLeaseExpirationTime(lease_duration);
+  EXPECT_EQ(kTimeNow + lease_duration,
+            ipconfig_->current_lease_expiration_time_.tv_sec);
+}
+
+TEST_F(IPConfigTest, TimeToLeaseExpiry_NoDHCPLease) {
+  ScopedMockLog log;
+  uint32_t time_left = 0;
+  // |current_lease_expiration_time_| has not been set, so expect an error.
+  EXPECT_CALL(log, Log(logging::LOG_ERROR, _,
+                       EndsWith("No current DHCP lease")));
+  EXPECT_FALSE(ipconfig_->TimeToLeaseExpiry(&time_left));
+  EXPECT_EQ(0, time_left);
+}
+
+TEST_F(IPConfigTest, TimeToLeaseExpiry_CurrentLeaseExpired) {
+  ScopedMockLog log;
+  const struct timeval time_now = {kTimeNow, 0};
+  uint32_t time_left = 0;
+  // Set |current_lease_expiration_time_| so it is expired (i.e. earlier than
+  // current time).
+  ipconfig_->current_lease_expiration_time_ = {kTimeNow - 1, 0};
+  EXPECT_CALL(time_, GetTimeBoottime(_))
+      .WillOnce(DoAll(SetArgPointee<0>(time_now), Return(0)));
+  EXPECT_CALL(log, Log(logging::LOG_ERROR, _,
+                       EndsWith("Current DHCP lease has already expired")));
+  EXPECT_FALSE(ipconfig_->TimeToLeaseExpiry(&time_left));
+  EXPECT_EQ(0, time_left);
+}
+
+TEST_F(IPConfigTest, TimeToLeaseExpiry_Success) {
+  const uint32_t expected_time_to_expiry = 10;
+  const struct timeval time_now = {kTimeNow, 0};
+  uint32_t time_left;
+  // Set |current_lease_expiration_time_| so it appears like we already
+  // have obtained a DHCP lease before.
+  ipconfig_->current_lease_expiration_time_ = {
+      kTimeNow + expected_time_to_expiry, 0};
+  EXPECT_CALL(time_, GetTimeBoottime(_))
+      .WillOnce(DoAll(SetArgPointee<0>(time_now), Return(0)));
+  EXPECT_TRUE(ipconfig_->TimeToLeaseExpiry(&time_left));
+  EXPECT_EQ(expected_time_to_expiry, time_left);
+}
+
 }  // namespace shill
diff --git a/shill/mock_ipconfig.h b/shill/mock_ipconfig.h
index d35bbcc..0d97b57 100644
--- a/shill/mock_ipconfig.h
+++ b/shill/mock_ipconfig.h
@@ -29,6 +29,8 @@
   MOCK_METHOD0(EmitChanges, void(void));
   MOCK_METHOD1(UpdateDNSServers,
                void(const std::vector<std::string> &dns_servers));
+  MOCK_METHOD1(UpdateLeaseExpirationTime, void(uint32_t new_lease_duration));
+  MOCK_METHOD0(ResetLeaseExpirationTime, void(void));
 
  private:
   const Properties &real_properties() {