diff --git a/device.cc b/device.cc
index d035735..6640c06 100644
--- a/device.cc
+++ b/device.cc
@@ -356,6 +356,10 @@
     SLOG(Device, 3) << "Renewing IP address on resume.";
     ipconfig_->RenewIP();
   }
+  if (link_monitor_) {
+    SLOG(Device, 3) << "Informing Link Monitor of resume.";
+    link_monitor_->OnAfterResume();
+  }
 }
 
 void Device::DropConnection() {
@@ -762,7 +766,7 @@
 
 void Device::StopPortalDetection() {
   SLOG(Device, 2) << "Device " << FriendlyName()
-                  << ": Portal detection has stopped.";
+                  << ": Portal detection stopping.";
   portal_detector_.reset();
 }
 
diff --git a/device_unittest.cc b/device_unittest.cc
index c053f4e..0ce8059 100644
--- a/device_unittest.cc
+++ b/device_unittest.cc
@@ -461,6 +461,19 @@
   device_->OnAfterResume();
 }
 
+TEST_F(DeviceTest, ResumeWithLinkMonitor) {
+  MockLinkMonitor *link_monitor = new StrictMock<MockLinkMonitor>();
+  SetLinkMonitor(link_monitor);  // Passes ownership.
+  EXPECT_CALL(*link_monitor, OnAfterResume());
+  device_->OnAfterResume();
+}
+
+TEST_F(DeviceTest, ResumeWithoutLinkMonitor) {
+  // Just test that we don't crash in this case.
+  EXPECT_FALSE(HasLinkMonitor());
+  device_->OnAfterResume();
+}
+
 TEST_F(DeviceTest, LinkMonitor) {
   scoped_refptr<MockConnection> connection(
       new StrictMock<MockConnection>(&device_info_));
diff --git a/link_monitor.cc b/link_monitor.cc
index 8bc7912..4fa7a15 100644
--- a/link_monitor.cc
+++ b/link_monitor.cc
@@ -28,9 +28,10 @@
 
 namespace shill {
 
-const int LinkMonitor::kTestPeriodMilliseconds = 5000;
+const int LinkMonitor::kDefaultTestPeriodMilliseconds = 5000;
 const char LinkMonitor::kDefaultLinkMonitorTechnologies[] = "wifi";
 const int LinkMonitor::kFailureThreshold = 5;
+const int LinkMonitor::kFastTestPeriodMilliseconds = 200;
 const int LinkMonitor::kMaxResponseSampleFilterDepth = 5;
 
 LinkMonitor::LinkMonitor(const ConnectionRefPtr &connection,
@@ -43,8 +44,11 @@
       metrics_(metrics),
       device_info_(device_info),
       failure_callback_(failure_callback),
+      test_period_milliseconds_(kDefaultTestPeriodMilliseconds),
       broadcast_failure_count_(0),
       unicast_failure_count_(0),
+      broadcast_success_count_(0),
+      unicast_success_count_(0),
       is_unicast_(false),
       response_sample_count_(0),
       response_sample_bucket_(0),
@@ -57,9 +61,17 @@
 
 bool LinkMonitor::Start() {
   Stop();
+  return StartInternal(kDefaultTestPeriodMilliseconds);
+}
+
+bool LinkMonitor::StartInternal(int probe_period_milliseconds) {
+  test_period_milliseconds_ = probe_period_milliseconds;
+  if (test_period_milliseconds_ > kDefaultTestPeriodMilliseconds) {
+    LOG(WARNING) << "Long test period; UMA stats will be truncated.";
+  }
 
   if (!device_info_->GetMACAddress(
-           connection_->interface_index(), &local_mac_address_)) {
+          connection_->interface_index(), &local_mac_address_)) {
     LOG(ERROR) << "Could not get local MAC address.";
     metrics_->NotifyLinkMonitorFailure(
         connection_->technology(),
@@ -68,7 +80,9 @@
     Stop();
     return false;
   }
-  gateway_mac_address_ = ByteString(local_mac_address_.GetLength());
+  if (gateway_mac_address_.IsEmpty()) {
+    gateway_mac_address_ = ByteString(local_mac_address_.GetLength());
+  }
   send_request_callback_.Reset(
       Bind(base::IgnoreResult(&LinkMonitor::SendRequest), Unretained(this)));
   time_->GetTimeMonotonic(&started_monitoring_at_);
@@ -82,6 +96,8 @@
   arp_client_.reset();
   broadcast_failure_count_ = 0;
   unicast_failure_count_ = 0;
+  broadcast_success_count_ = 0;
+  unicast_success_count_ = 0;
   is_unicast_ = false;
   response_sample_bucket_ = 0;
   response_sample_count_ = 0;
@@ -91,6 +107,13 @@
   timerclear(&sent_request_at_);
 }
 
+void LinkMonitor::OnAfterResume() {
+  ByteString prior_gateway_mac_address(gateway_mac_address_);
+  Stop();
+  gateway_mac_address_ = prior_gateway_mac_address;
+  StartInternal(kFastTestPeriodMilliseconds);
+}
+
 int LinkMonitor::GetResponseTimeMilliseconds() const {
   return response_sample_count_ ?
       response_sample_bucket_ / response_sample_count_ : 0;
@@ -139,12 +162,14 @@
 
 bool LinkMonitor::AddMissedResponse() {
   SLOG(Link, 2) << "In " << __func__ << ".";
-  AddResponseTimeSample(kTestPeriodMilliseconds);
+  AddResponseTimeSample(test_period_milliseconds_);
 
   if (is_unicast_) {
     ++unicast_failure_count_;
+    unicast_success_count_ = 0;
   } else {
     ++broadcast_failure_count_;
+    broadcast_success_count_ = 0;
   }
 
   if (unicast_failure_count_ + broadcast_failure_count_ >= kFailureThreshold) {
@@ -213,8 +238,10 @@
   arp_client_.reset();
 
   if (is_unicast_) {
+    ++unicast_success_count_;
     unicast_failure_count_ = 0;
   } else {
+    ++broadcast_success_count_;
     broadcast_failure_count_ = 0;
   }
 
@@ -230,6 +257,9 @@
   }
 
   is_unicast_ = !is_unicast_;
+  if (unicast_success_count_ && broadcast_success_count_) {
+    test_period_milliseconds_ = kDefaultTestPeriodMilliseconds;
+  }
 }
 
 bool LinkMonitor::SendRequest() {
@@ -284,7 +314,7 @@
   time_->GetTimeMonotonic(&sent_request_at_);
 
   dispatcher_->PostDelayedTask(send_request_callback_.callback(),
-                               kTestPeriodMilliseconds);
+                               test_period_milliseconds_);
   return true;
 }
 
diff --git a/link_monitor.h b/link_monitor.h
index 074e5a3..ff6785b 100644
--- a/link_monitor.h
+++ b/link_monitor.h
@@ -37,10 +37,11 @@
   // are reset, and the link monitoring quiesces.  Needed by Metrics.
   static const int kFailureThreshold;
 
-  // The number of milliseconds between ARP requests.  Needed by Metrics.
-  static const int kTestPeriodMilliseconds;
+  // The default number of milliseconds between ARP requests. Needed by Metrics.
+  static const int kDefaultTestPeriodMilliseconds;
 
   // The default list of technologies for which link monitoring is enabled.
+  // Needed by DefaultProfile.
   static const char kDefaultLinkMonitorTechnologies[];
 
   LinkMonitor(const ConnectionRefPtr &connection,
@@ -53,8 +54,15 @@
   // Starts link-monitoring on the selected connection.  Returns
   // true if successful, false otherwise.
   virtual bool Start();
+  // Stop link-monitoring on the selected connection. Clears any
+  // accumulated statistics.
   virtual void Stop();
 
+  // Inform LinkMonitor that the system is resuming from sleep.
+  // LinkMonitor will immediately probe the gateway, using a lower
+  // timeout than normal.
+  virtual void OnAfterResume();
+
   // Return modified cumulative average of the gateway ARP response
   // time.  Returns zero if no samples are available.  For each
   // missed ARP response, the sample is assumed to be the full
@@ -69,11 +77,20 @@
   friend class LinkMonitorForTest;
   friend class LinkMonitorTest;
 
+  // The number of milliseconds between ARP requests when running a quick test.
+  // Needed by unit tests.
+  static const int kFastTestPeriodMilliseconds;
+
   // The number of samples to compute a "strict" average over.  When
   // more samples than this number arrive, this determines how "slow"
   // our simple low-pass filter works.
   static const int kMaxResponseSampleFilterDepth;
 
+  // Similar to Start, except that the initial probes use
+  // |probe_period_milliseconds|. After successfully probing with both
+  // broadcast and unicast ARPs (at least one of each), LinkMonitor
+  // switches itself to kDefaultTestPeriodMilliseconds.
+  virtual bool StartInternal(int probe_period_milliseconds);
   // Add a response time sample to the buffer.
   void AddResponseTimeSample(int response_time_milliseconds);
   // Create an ArpClient instance so we can receive and transmit ARP
@@ -109,12 +126,21 @@
   // ArpClient instance used for performing link tests.
   scoped_ptr<ArpClient> arp_client_;
 
+  // How frequently we send an ARP request. This is also the timeout
+  // for a pending request.
+  int test_period_milliseconds_;
   // The number of consecutive times we have failed in receiving
   // responses to broadcast ARP requests.
   int broadcast_failure_count_;
   // The number of consecutive times we have failed in receiving
   // responses to unicast ARP requests.
   int unicast_failure_count_;
+  // The number of consecutive times we have succeeded in receiving
+  // responses to broadcast ARP requests.
+  int broadcast_success_count_;
+  // The number of consecutive times we have succeeded in receiving
+  // responses to unicast ARP requests.
+  int unicast_success_count_;
 
   // Whether this iteration of the test was a unicast request
   // to the gateway instead of broadcast.  The link monitor
diff --git a/link_monitor_unittest.cc b/link_monitor_unittest.cc
index 0bfae85..72db7f4 100644
--- a/link_monitor_unittest.cc
+++ b/link_monitor_unittest.cc
@@ -68,11 +68,33 @@
 };
 
 MATCHER_P4(IsArpRequest, local_ip, remote_ip, local_mac, remote_mac, "") {
-  return
-      local_ip.Equals(arg.local_ip_address()) &&
+  if (local_ip.Equals(arg.local_ip_address()) &&
       remote_ip.Equals(arg.remote_ip_address()) &&
       local_mac.Equals(arg.local_mac_address()) &&
-      remote_mac.Equals(arg.remote_mac_address());
+      remote_mac.Equals(arg.remote_mac_address()))
+    return true;
+
+  if (!local_ip.Equals(arg.local_ip_address())) {
+    *result_listener << "Local IP '" << arg.local_ip_address().ToString()
+                     << "' (wanted '" << local_ip.ToString() << "').";
+  }
+
+  if (!remote_ip.Equals(arg.remote_ip_address())) {
+    *result_listener << "Remote IP '" << arg.remote_ip_address().ToString()
+                     << "' (wanted '" << remote_ip.ToString() << "').";
+  }
+
+  if (!local_mac.Equals(arg.local_mac_address())) {
+    *result_listener << "Local MAC '" << arg.local_mac_address().HexEncode()
+                     << "' (wanted " << local_mac.HexEncode() << ")'.";
+  }
+
+  if (!remote_mac.Equals(arg.remote_mac_address())) {
+    *result_listener << "Remote MAC '" << arg.remote_mac_address().HexEncode()
+                     << "' (wanted " << remote_mac.HexEncode() << ")'.";
+  }
+
+  return false;
 }
 
 class LinkMonitorTest : public Test {
@@ -153,6 +175,8 @@
     EXPECT_TRUE(GetSendRequestCallback().IsCancelled());
     EXPECT_EQ(0, GetBroadcastFailureCount());
     EXPECT_EQ(0, GetUnicastFailureCount());
+    EXPECT_EQ(0, GetBroadcastSuccessCount());
+    EXPECT_EQ(0, GetUnicastSuccessCount());
     EXPECT_FALSE(IsUnicast());
   }
   const ArpClient *GetArpClient() { return monitor_.arp_client_.get(); }
@@ -168,17 +192,29 @@
   int GetUnicastFailureCount() {
     return monitor_.unicast_failure_count_;
   }
-  bool IsUnicast() { return monitor_.is_unicast_; }
-  int GetTestPeriodMilliseconds() {
-    return LinkMonitor::kTestPeriodMilliseconds;
+  int GetBroadcastSuccessCount() {
+    return monitor_.broadcast_success_count_;
   }
-  int GetFailureThreshold() {
+  int GetUnicastSuccessCount() {
+    return monitor_.unicast_success_count_;
+  }
+  bool IsUnicast() { return monitor_.is_unicast_; }
+  int GetCurrentTestPeriodMilliseconds() {
+    return monitor_.test_period_milliseconds_;
+  }
+  int GetDefaultTestPeriodMilliseconds() {
+    return LinkMonitor::kDefaultTestPeriodMilliseconds;
+  }
+  size_t GetFailureThreshold() {
     return LinkMonitor::kFailureThreshold;
   }
+  int GetFastTestPeriodMilliseconds() {
+    return LinkMonitor::kFastTestPeriodMilliseconds;
+  }
   int GetMaxResponseSampleFilterDepth() {
     return LinkMonitor::kMaxResponseSampleFilterDepth;
   }
-  void ExpectTransmit(bool is_unicast) {
+  void ExpectTransmit(bool is_unicast, int transmit_period_milliseconds) {
     const ByteString &destination_mac = is_unicast ? gateway_mac_ : zero_mac_;
     if (monitor_.arp_client_.get()) {
       EXPECT_EQ(client_, monitor_.arp_client_.get());
@@ -192,13 +228,15 @@
           IsArpRequest(local_ip_, gateway_ip_, local_mac_, destination_mac)))
           .WillOnce(Return(true));
     }
-    EXPECT_CALL(dispatcher_, PostDelayedTask(_, GetTestPeriodMilliseconds()));
+    EXPECT_CALL(dispatcher_,
+                PostDelayedTask(_, transmit_period_milliseconds));
   }
   void SendNextRequest() {
     EXPECT_CALL(monitor_, CreateClient())
         .WillOnce(Invoke(this, &LinkMonitorTest::CreateMockClient));
     EXPECT_CALL(*next_client_, TransmitRequest(_)).WillOnce(Return(true));
-    EXPECT_CALL(dispatcher_, PostDelayedTask(_, GetTestPeriodMilliseconds()));
+    EXPECT_CALL(dispatcher_,
+                PostDelayedTask(_, GetCurrentTestPeriodMilliseconds()));
     TriggerRequestTimer();
   }
   void ExpectNoTransmit() {
@@ -206,15 +244,31 @@
       monitor_.arp_client_.get() ? client_ : next_client_;
     EXPECT_CALL(*client, TransmitRequest(_)).Times(0);
   }
+  void ExpectRestart(int transmit_period_milliseconds) {
+    EXPECT_CALL(device_info_, GetMACAddress(0, _))
+        .WillOnce(DoAll(SetArgumentPointee<1>(local_mac_), Return(true)));
+    // Can't just use ExpectTransmit, because that depends on state
+    // that changes during Stop.
+    EXPECT_CALL(monitor_, CreateClient())
+        .WillOnce(Invoke(this, &LinkMonitorTest::CreateMockClient));
+    EXPECT_CALL(*next_client_, TransmitRequest(
+        IsArpRequest(local_ip_, gateway_ip_, local_mac_, zero_mac_)))
+        .WillOnce(Return(true));
+    EXPECT_CALL(dispatcher_,
+                PostDelayedTask(_, transmit_period_milliseconds));
+  }
   void StartMonitor() {
     EXPECT_CALL(device_info_, GetMACAddress(0, _))
         .WillOnce(DoAll(SetArgumentPointee<1>(local_mac_), Return(true)));
-    ExpectTransmit(false);
+    ExpectTransmit(false, GetDefaultTestPeriodMilliseconds());
     EXPECT_TRUE(monitor_.Start());
     EXPECT_TRUE(GetArpClient());
     EXPECT_FALSE(IsUnicast());
     EXPECT_FALSE(GetSendRequestCallback().IsCancelled());
   }
+  void ReportResume() {
+    monitor_.OnAfterResume();
+  }
   bool SimulateReceiveReply(ArpPacket *packet, ByteString *sender) {
     packet->set_local_ip_address(rx_packet_.local_ip_address());
     packet->set_remote_ip_address(rx_packet_.remote_ip_address());
@@ -238,6 +292,9 @@
   void ReceiveCorrectResponse() {
     ReceiveResponse(gateway_ip_, gateway_mac_, local_ip_, local_mac_);
   }
+  bool IsGatewayFound() {
+    return monitor_.IsGatewayFound();
+  }
 
   MockEventDispatcher dispatcher_;
   StrictMock<MockMetrics> metrics_;
@@ -359,22 +416,25 @@
 
 TEST_F(LinkMonitorTest, TimeoutBroadcast) {
   EXPECT_CALL(metrics_, SendToUMA(
-      HasSubstr("LinkMonitorResponseTimeSample"), GetTestPeriodMilliseconds(),
+      HasSubstr("LinkMonitorResponseTimeSample"),
+      GetDefaultTestPeriodMilliseconds(),
       _, _, _)).Times(GetFailureThreshold());
   StartMonitor();
-  // This value doesn't match real life (the timer in this scenario should
-  // advance by LinkMonitor::kTestPeriodMilliseconds), but this demonstrates
-  // the LinkMonitorSecondsToFailure independent from the response-time
-  // figures.
+  // This value doesn't match real life (the timer in this scenario
+  // should advance by LinkMonitor::kDefaultTestPeriodMilliseconds),
+  // but this demonstrates the LinkMonitorSecondsToFailure independent
+  // from the response-time figures.
   const int kTimeIncrement = 1000;
-  for (int i = 1; i < GetFailureThreshold(); ++i) {
-    ExpectTransmit(false);
+  for (size_t i = 1; i < GetFailureThreshold(); ++i) {
+    ExpectTransmit(false, GetDefaultTestPeriodMilliseconds());
     AdvanceTime(kTimeIncrement);
     TriggerRequestTimer();
     EXPECT_FALSE(IsUnicast());
     EXPECT_EQ(i, GetBroadcastFailureCount());
     EXPECT_EQ(0, GetUnicastFailureCount());
-    EXPECT_EQ(GetTestPeriodMilliseconds(),
+    EXPECT_EQ(0, GetBroadcastSuccessCount());
+    EXPECT_EQ(0, GetUnicastSuccessCount());
+    EXPECT_EQ(GetDefaultTestPeriodMilliseconds(),
               monitor_.GetResponseTimeMilliseconds());
   }
   ScopedMockLog log;
@@ -408,24 +468,27 @@
       .Times(GetFailureThreshold());
   // Unsuccessful unicast receptions.
   EXPECT_CALL(metrics_, SendToUMA(
-      HasSubstr("LinkMonitorResponseTimeSample"), GetTestPeriodMilliseconds(),
+      HasSubstr("LinkMonitorResponseTimeSample"),
+      GetDefaultTestPeriodMilliseconds(),
       _, _, _)).Times(GetFailureThreshold());
   ReceiveCorrectResponse();
-  for (int i = 1; i < GetFailureThreshold(); ++i) {
+  for (size_t i = 1; i < GetFailureThreshold(); ++i) {
     // Failed unicast ARP.
-    ExpectTransmit(true);
+    ExpectTransmit(true, GetDefaultTestPeriodMilliseconds());
     TriggerRequestTimer();
 
     // Successful broadcast ARP.
-    ExpectTransmit(false);
+    ExpectTransmit(false, GetDefaultTestPeriodMilliseconds());
     TriggerRequestTimer();
     ReceiveCorrectResponse();
 
     EXPECT_EQ(0, GetBroadcastFailureCount());
     EXPECT_EQ(i, GetUnicastFailureCount());
+    EXPECT_EQ(i+1, GetBroadcastSuccessCount());  // One before loop.
+    EXPECT_EQ(0, GetUnicastSuccessCount());
   }
   // Last unicast ARP transmission.
-  ExpectTransmit(true);
+  ExpectTransmit(true, GetDefaultTestPeriodMilliseconds());
   TriggerRequestTimer();
 
   ScopedMockLog log;
@@ -449,6 +512,83 @@
   ExpectReset();
 }
 
+TEST_F(LinkMonitorTest, OnAfterResume) {
+  const int kFastTestPeriodMilliseconds = GetFastTestPeriodMilliseconds();
+  StartMonitor();
+  Mock::VerifyAndClearExpectations(&monitor_);
+
+  // Resume should preserve the fact that we haven't resolved the gateway's MAC.
+  EXPECT_FALSE(IsGatewayFound());
+  ExpectRestart(kFastTestPeriodMilliseconds);
+  ReportResume();
+  EXPECT_FALSE(IsGatewayFound());
+
+  // After resume, we should use the fast test period...
+  ExpectRestart(kFastTestPeriodMilliseconds);
+  ReportResume();
+  EXPECT_EQ(kFastTestPeriodMilliseconds, GetCurrentTestPeriodMilliseconds());
+
+  // ...and the fast period should be used for reporting failure to UMA...
+  EXPECT_CALL(metrics_, SendToUMA(
+      HasSubstr("LinkMonitorResponseTimeSample"), kFastTestPeriodMilliseconds,
+      _, _, _));
+  ExpectTransmit(false, kFastTestPeriodMilliseconds);
+  TriggerRequestTimer();
+
+  // ...and the period should be reset after correct responses on both
+  // broadcast and unicast.
+  const int kResponseTime = 12;
+  EXPECT_CALL(metrics_, SendToUMA(
+      HasSubstr("LinkMonitorResponseTimeSample"), kResponseTime,  _, _, _))
+      .Times(2);
+  AdvanceTime(kResponseTime);
+  ReceiveCorrectResponse();
+  EXPECT_EQ(GetFastTestPeriodMilliseconds(),
+            GetCurrentTestPeriodMilliseconds());  // Don't change yet.
+  ExpectTransmit(true, kFastTestPeriodMilliseconds);
+  TriggerRequestTimer();
+  AdvanceTime(kResponseTime);
+  ReceiveCorrectResponse();
+  EXPECT_EQ(1, GetBroadcastSuccessCount());
+  EXPECT_EQ(1, GetUnicastSuccessCount());
+  EXPECT_EQ(GetDefaultTestPeriodMilliseconds(),
+            GetCurrentTestPeriodMilliseconds());
+
+  // Resume should preserve the fact that we _have_ resolved the gateway's MAC.
+  EXPECT_TRUE(IsGatewayFound());
+  ExpectRestart(kFastTestPeriodMilliseconds);
+  ReportResume();
+  EXPECT_TRUE(IsGatewayFound());
+
+  // Failure should happen just like normal.
+  ExpectRestart(kFastTestPeriodMilliseconds);
+  ReportResume();
+  EXPECT_CALL(metrics_, SendToUMA(
+      HasSubstr("LinkMonitorResponseTimeSample"), kFastTestPeriodMilliseconds,
+      _, _, _))
+      .Times(GetFailureThreshold());
+  EXPECT_CALL(metrics_, SendEnumToUMA(
+      HasSubstr("LinkMonitorFailure"),
+      Metrics::kLinkMonitorFailureThresholdReached, _));
+  EXPECT_CALL(metrics_, SendToUMA(
+      HasSubstr("LinkMonitorSecondsToFailure"), _, _, _, _));
+  EXPECT_CALL(metrics_, SendToUMA(
+      HasSubstr("BroadcastErrorsAtFailure"), GetFailureThreshold() / 2 + 1,
+      _, _, _));
+  EXPECT_CALL(metrics_, SendToUMA(
+      HasSubstr("UnicastErrorsAtFailure"), GetFailureThreshold() / 2,
+      _, _, _));
+  EXPECT_CALL(monitor_, FailureCallbackHandler());
+  bool unicast_probe = true;
+  for (size_t i = 1 ; i < GetFailureThreshold(); ++i) {
+    ExpectTransmit(unicast_probe, GetFastTestPeriodMilliseconds());
+    TriggerRequestTimer();
+    unicast_probe = !unicast_probe;
+  }
+  TriggerRequestTimer();
+  ExpectReset();
+}
+
 TEST_F(LinkMonitorTest, Average) {
   const int kSamples[] = { 200, 950, 1200, 4096, 5000,
                            86, 120, 3060, 842, 750 };
diff --git a/metrics.cc b/metrics.cc
index 903bd0d..41b6f9f 100644
--- a/metrics.cc
+++ b/metrics.cc
@@ -189,7 +189,7 @@
     "Network.Shill.%s.LinkMonitorResponseTimeSample";
 const int Metrics::kMetricLinkMonitorResponseTimeSampleMin = 0;
 const int Metrics::kMetricLinkMonitorResponseTimeSampleMax =
-    LinkMonitor::kTestPeriodMilliseconds;
+    LinkMonitor::kDefaultTestPeriodMilliseconds;
 const int Metrics::kMetricLinkMonitorResponseTimeSampleNumBuckets = 50;
 const char Metrics::kMetricLinkMonitorSecondsToFailure[] =
     "Network.Shill.%s.LinkMonitorSecondsToFailure";
diff --git a/mock_link_monitor.h b/mock_link_monitor.h
index 17f083f..690669d 100644
--- a/mock_link_monitor.h
+++ b/mock_link_monitor.h
@@ -18,6 +18,7 @@
 
   MOCK_METHOD0(Start, bool());
   MOCK_METHOD0(Stop, void());
+  MOCK_METHOD0(OnAfterResume, void());
   MOCK_CONST_METHOD0(GetResponseTimeMilliseconds, int());
   MOCK_CONST_METHOD0(IsGatewayFound, bool());