Fix PrivetNotificationService::PrivetNotify() silliness.

chrome/browser/printing/cloud_print/privet_notifications_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/printing/cloud_print/privet_notifications.h"
 
 #include <memory>
 
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 51 matching lines @@
     }
 
     const std::string& GetName() override { return name_; }
 
    private:
     std::string name_;
     scoped_refptr<net::URLRequestContextGetter> request_context_;
   };
 
   explicit MockPrivetHttpFactory(net::URLRequestContextGetter* request_context)
-      : request_context_(request_context) {
-  }
+      : request_context_(request_context) {}
 
   std::unique_ptr<PrivetHTTPResolution> CreatePrivetHTTP(
       const std::string& name) override {
     return base::WrapUnique(new MockResolution(name, request_context_.get()));
   }
 
  private:
-    scoped_refptr<net::URLRequestContextGetter> request_context_;
+  scoped_refptr<net::URLRequestContextGetter> request_context_;
 };
 
 class PrivetNotificationsListenerTest : public ::testing::Test {
  public:
   PrivetNotificationsListenerTest()
       : request_context_(new net::TestURLRequestContextGetter(
             base::ThreadTaskRunnerHandle::Get())) {
     notification_listener_.reset(new PrivetNotificationsListener(
         std::unique_ptr<PrivetHTTPAsynchronousFactory>(
             new MockPrivetHttpFactory(request_context_.get())),
         &mock_delegate_));
 
     description_.name = kExampleDeviceHumanName;
     description_.description = kExampleDeviceDescription;
   }
 
-  virtual ~PrivetNotificationsListenerTest() {
-  }
+  virtual ~PrivetNotificationsListenerTest() {}
 
   bool SuccessfulResponseToInfo(const std::string& response) {
     net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
-    EXPECT_TRUE(fetcher);
-    EXPECT_EQ(GURL(kDeviceInfoURL), fetcher->GetOriginalURL());
-
     if (!fetcher || GURL(kDeviceInfoURL) != fetcher->GetOriginalURL())
       return false;
 
     fetcher->SetResponseString(response);
-    fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
-                                              net::OK));
+    fetcher->set_status(
+        net::URLRequestStatus(net::URLRequestStatus::SUCCESS, net::OK));
     fetcher->set_response_code(200);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     return true;
   }
 
  protected:
   StrictMock<MockPrivetNotificationsListenerDeleagate> mock_delegate_;
   std::unique_ptr<PrivetNotificationsListener> notification_listener_;
   base::MessageLoop message_loop_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
   net::TestURLFetcherFactory fetcher_factory_;
   DeviceDescription description_;
 };
 
 TEST_F(PrivetNotificationsListenerTest, DisappearReappearTest) {
-  EXPECT_CALL(mock_delegate_, PrivetNotify(
-      1,
-      true));
-
-  notification_listener_->DeviceChanged(
-      kExampleDeviceName,
-      description_);
-
-  SuccessfulResponseToInfo(kInfoResponseUptime20);
+  EXPECT_CALL(mock_delegate_, PrivetNotify(1, true));
+  notification_listener_->DeviceChanged(kExampleDeviceName, description_);
+  EXPECT_TRUE(SuccessfulResponseToInfo(kInfoResponseUptime20));
 
   EXPECT_CALL(mock_delegate_, PrivetRemoveNotification());
-
-  notification_listener_->DeviceRemoved(
-      kExampleDeviceName);
-
-  notification_listener_->DeviceChanged(
-      kExampleDeviceName,
-      description_);
-
+  notification_listener_->DeviceRemoved(kExampleDeviceName);
+  notification_listener_->DeviceChanged(kExampleDeviceName, description_);
   description_.id = kExampleDeviceID;
-
-  notification_listener_->DeviceChanged(
-      kExampleDeviceName,
-      description_);
+  notification_listener_->DeviceChanged(kExampleDeviceName, description_);
 }
 
 TEST_F(PrivetNotificationsListenerTest, RegisterTest) {
-  EXPECT_CALL(mock_delegate_, PrivetNotify(
-      1,
-      true));
-
-  notification_listener_->DeviceChanged(
-      kExampleDeviceName,
-      description_);
-
-  SuccessfulResponseToInfo(kInfoResponseUptime20);
+  EXPECT_CALL(mock_delegate_, PrivetNotify(1, true));
+  notification_listener_->DeviceChanged(kExampleDeviceName, description_);
+  EXPECT_TRUE(SuccessfulResponseToInfo(kInfoResponseUptime20));
 
   EXPECT_CALL(mock_delegate_, PrivetRemoveNotification());
+  description_.id = kExampleDeviceID;
+  notification_listener_->DeviceChanged(kExampleDeviceName, description_);
+}
 
-  description_.id = kExampleDeviceID;
+TEST_F(PrivetNotificationsListenerTest, RepeatedNotification) {
+  EXPECT_CALL(mock_delegate_, PrivetNotify(1, true));
+  notification_listener_->DeviceChanged(kExampleDeviceName, description_);
+  EXPECT_TRUE(SuccessfulResponseToInfo(kInfoResponseUptime20));
 
-  notification_listener_->DeviceChanged(
-      kExampleDeviceName,
-      description_);
+  EXPECT_CALL(mock_delegate_, PrivetNotify(_, _)).Times(0);
+  notification_listener_->DeviceChanged(kExampleDeviceName, description_);
+
+  EXPECT_CALL(mock_delegate_, PrivetRemoveNotification());
+  notification_listener_->DeviceRemoved(kExampleDeviceName);
+
+  EXPECT_CALL(mock_delegate_, PrivetNotify(_, _)).Times(0);
+  notification_listener_->DeviceChanged(kExampleDeviceName, description_);
+
+  EXPECT_CALL(mock_delegate_, PrivetRemoveNotification()).Times(0);
+  notification_listener_->DeviceRemoved(kExampleDeviceName);
 }
 
 TEST_F(PrivetNotificationsListenerTest, HighUptimeTest) {
-  notification_listener_->DeviceChanged(
-      kExampleDeviceName,
-      description_);
-
-  SuccessfulResponseToInfo(kInfoResponseUptime3600);
-
+  notification_listener_->DeviceChanged(kExampleDeviceName, description_);
+  EXPECT_TRUE(SuccessfulResponseToInfo(kInfoResponseUptime3600));
   description_.id = kExampleDeviceID;
-
-  notification_listener_->DeviceChanged(
-      kExampleDeviceName,
-      description_);
+  notification_listener_->DeviceChanged(kExampleDeviceName, description_);
 }
 
 TEST_F(PrivetNotificationsListenerTest, HTTPErrorTest) {
-  notification_listener_->DeviceChanged(
-      kExampleDeviceName,
-      description_);
-
+  notification_listener_->DeviceChanged(kExampleDeviceName, description_);
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
-
-  fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
-                                            net::OK));
+  fetcher->set_status(
+      net::URLRequestStatus(net::URLRequestStatus::SUCCESS, net::OK));
   fetcher->set_response_code(200);
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 }
 
 TEST_F(PrivetNotificationsListenerTest, DictionaryErrorTest) {
-  notification_listener_->DeviceChanged(
-      kExampleDeviceName,
-      description_);
-
+  notification_listener_->DeviceChanged(kExampleDeviceName, description_);
   SuccessfulResponseToInfo(kInfoResponseNoUptime);
 }
 
 }  // namespace
 
 }  // namespace cloud_print