Make AttachmentServiceImpl clear backoff when reconnected to network.

sync/internal_api/attachments/attachment_service_impl_unittest.cc

 // Copyright 2014 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 "sync/internal_api/public/attachments/attachment_service_impl.h"
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/timer/mock_timer.h"
 #include "sync/internal_api/public/attachments/fake_attachment_downloader.h"
 #include "sync/internal_api/public/attachments/fake_attachment_uploader.h"
 #include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 class MockAttachmentStore : public AttachmentStore,
                             public base::SupportsWeakPtr<MockAttachmentStore> {
  public:
@@ skipping 127 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MockAttachmentUploader);
 };
 
 class AttachmentServiceImplTest : public testing::Test,
                                   public AttachmentService::Delegate {
  protected:
   AttachmentServiceImplTest() {}
 
   virtual void SetUp() OVERRIDE {
+    network_change_notifier_.reset(net::NetworkChangeNotifier::CreateMock());
     InitializeAttachmentService(make_scoped_ptr(new MockAttachmentUploader()),
                                 make_scoped_ptr(new MockAttachmentDownloader()),
                                 this);
   }
 
   virtual void TearDown() OVERRIDE {
     attachment_service_.reset();
     ASSERT_FALSE(attachment_store_);
     ASSERT_FALSE(attachment_uploader_);
     ASSERT_FALSE(attachment_downloader_);
@@ skipping 17 matching lines @@
       attachment_uploader_ = uploader->AsWeakPtr();
     }
     if (downloader.get()) {
       attachment_downloader_ = downloader->AsWeakPtr();
     }
     attachment_service_.reset(
         new AttachmentServiceImpl(attachment_store,
                                   uploader.PassAs<AttachmentUploader>(),
                                   downloader.PassAs<AttachmentDownloader>(),
                                   delegate,
-                                  base::TimeDelta(),
-                                  base::TimeDelta()));
+                                  base::TimeDelta::FromMinutes(1),
+                                  base::TimeDelta::FromMinutes(8)));
+
+    scoped_ptr<base::MockTimer> timer_to_pass(
+        new base::MockTimer(false, false));
+    mock_timer_ = timer_to_pass.get();
+    attachment_service_->SetTimerForTest(timer_to_pass.PassAs<base::Timer>());
   }
 
   AttachmentService* attachment_service() { return attachment_service_.get(); }
 
+  base::MockTimer* mock_timer() { return mock_timer_; }
+
   AttachmentService::GetOrDownloadCallback download_callback() {
     return base::Bind(&AttachmentServiceImplTest::DownloadDone,
                       base::Unretained(this));
   }
 
   void DownloadDone(const AttachmentService::GetOrDownloadResult& result,
                     scoped_ptr<AttachmentMap> attachments) {
     download_results_.push_back(result);
     last_download_attachments_ = attachments.Pass();
   }
 
   void RunLoop() {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
+  void RunLoopAndFireTimer() {
+    RunLoop();
+    if (mock_timer()->IsRunning()) {
+      mock_timer()->Fire();
+    }
+    RunLoop();
+  }
+
   const std::vector<AttachmentService::GetOrDownloadResult>&
   download_results() const {
     return download_results_;
   }
 
   const AttachmentMap& last_download_attachments() const {
     return *last_download_attachments_.get();
   }
 
+  net::NetworkChangeNotifier* network_change_notifier() {
+    return network_change_notifier_.get();
+  }
+
   MockAttachmentStore* store() { return attachment_store_.get(); }
 
   MockAttachmentDownloader* downloader() {
     return attachment_downloader_.get();
   }
 
   MockAttachmentUploader* uploader() {
     return attachment_uploader_.get();
   }
 
   const std::vector<AttachmentId>& on_attachment_uploaded_list() const {
     return on_attachment_uploaded_list_;
   }
 
  private:
   base::MessageLoop message_loop_;
+  scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
   base::WeakPtr<MockAttachmentStore> attachment_store_;
   base::WeakPtr<MockAttachmentDownloader> attachment_downloader_;
   base::WeakPtr<MockAttachmentUploader> attachment_uploader_;
-  scoped_ptr<AttachmentService> attachment_service_;
+  scoped_ptr<AttachmentServiceImpl> attachment_service_;
+  base::MockTimer* mock_timer_;  // not owned
 
   std::vector<AttachmentService::GetOrDownloadResult> download_results_;
   scoped_ptr<AttachmentMap> last_download_attachments_;
   std::vector<AttachmentId> on_attachment_uploaded_list_;
 };
 
 TEST_F(AttachmentServiceImplTest, GetStore) {
   EXPECT_EQ(store(), attachment_service()->GetStore());
 }
 
@@ skipping 90 matching lines @@
 
 TEST_F(AttachmentServiceImplTest, UploadAttachments_Success) {
   AttachmentIdSet attachment_ids;
   const unsigned num_attachments = 3;
   for (unsigned i = 0; i < num_attachments; ++i) {
     attachment_ids.insert(AttachmentId::Create());
   }
   attachment_service()->UploadAttachments(attachment_ids);
 
   for (unsigned i = 0; i < num_attachments; ++i) {
-    RunLoop();
+    RunLoopAndFireTimer();
     // See that the service has issued a read for at least one of the
     // attachments.
-    ASSERT_GE(1U, store()->read_ids.size());
+    ASSERT_GE(store()->read_ids.size(), 1U);
     store()->RespondToRead(attachment_ids);
     RunLoop();
-    ASSERT_GE(1U, uploader()->upload_requests.size());
+    ASSERT_GE(uploader()->upload_requests.size(), 1U);
     uploader()->RespondToUpload(uploader()->upload_requests.begin()->first,
                                 AttachmentUploader::UPLOAD_SUCCESS);
   }
   RunLoop();
   ASSERT_EQ(0U, store()->read_ids.size());
   ASSERT_EQ(0U, uploader()->upload_requests.size());
 
   // See that all the attachments were uploaded.
   ASSERT_EQ(attachment_ids.size(), on_attachment_uploaded_list().size());
   AttachmentIdSet::const_iterator iter = attachment_ids.begin();
   const AttachmentIdSet::const_iterator end = attachment_ids.end();
   for (iter = attachment_ids.begin(); iter != end; ++iter) {
     EXPECT_THAT(on_attachment_uploaded_list(), testing::Contains(*iter));
   }
 }
 
 TEST_F(AttachmentServiceImplTest, UploadAttachments_Success_NoDelegate) {
   InitializeAttachmentService(make_scoped_ptr(new MockAttachmentUploader()),
                               make_scoped_ptr(new MockAttachmentDownloader()),
                               NULL);  // No delegate.
 
   AttachmentIdSet attachment_ids;
   attachment_ids.insert(AttachmentId::Create());
   attachment_service()->UploadAttachments(attachment_ids);
-  RunLoop();
-  EXPECT_EQ(1U, store()->read_ids.size());
-  EXPECT_EQ(0U, uploader()->upload_requests.size());
+  RunLoopAndFireTimer();
+  ASSERT_EQ(1U, store()->read_ids.size());
+  ASSERT_EQ(0U, uploader()->upload_requests.size());
   store()->RespondToRead(attachment_ids);
   RunLoop();
-  EXPECT_EQ(0U, store()->read_ids.size());
-  EXPECT_EQ(1U, uploader()->upload_requests.size());
+  ASSERT_EQ(0U, store()->read_ids.size());
+  ASSERT_EQ(1U, uploader()->upload_requests.size());
   uploader()->RespondToUpload(*attachment_ids.begin(),
                               AttachmentUploader::UPLOAD_SUCCESS);
   RunLoop();
   ASSERT_TRUE(on_attachment_uploaded_list().empty());
 }
 
 TEST_F(AttachmentServiceImplTest, UploadAttachments_SomeMissingFromStore) {
   AttachmentIdSet attachment_ids;
   attachment_ids.insert(AttachmentId::Create());
   attachment_ids.insert(AttachmentId::Create());
   attachment_service()->UploadAttachments(attachment_ids);
-  RunLoop();
-  ASSERT_GE(1U, store()->read_ids.size());
+  RunLoopAndFireTimer();
+  ASSERT_GE(store()->read_ids.size(), 1U);
 
   ASSERT_EQ(0U, uploader()->upload_requests.size());
   store()->RespondToRead(attachment_ids);
   RunLoop();
   ASSERT_EQ(1U, uploader()->upload_requests.size());
 
   uploader()->RespondToUpload(uploader()->upload_requests.begin()->first,
                               AttachmentUploader::UPLOAD_SUCCESS);
-  RunLoop();
+  RunLoopAndFireTimer();
   ASSERT_EQ(1U, on_attachment_uploaded_list().size());
-  ASSERT_GE(1U, store()->read_ids.size());
+  ASSERT_GE(store()->read_ids.size(), 1U);
   // Not found!
   store()->RespondToRead(AttachmentIdSet());
   RunLoop();
   // No upload requests since the read failed.
   ASSERT_EQ(0U, uploader()->upload_requests.size());
 }
 
 TEST_F(AttachmentServiceImplTest, UploadAttachments_AllMissingFromStore) {
   AttachmentIdSet attachment_ids;
   const unsigned num_attachments = 2;
   for (unsigned i = 0; i < num_attachments; ++i) {
     attachment_ids.insert(AttachmentId::Create());
   }
   attachment_service()->UploadAttachments(attachment_ids);
 
   for (unsigned i = 0; i < num_attachments; ++i) {
-    RunLoop();
-    ASSERT_GE(1U, store()->read_ids.size());
+    RunLoopAndFireTimer();
+    ASSERT_GE(store()->read_ids.size(), 1U);
     // None found!
     store()->RespondToRead(AttachmentIdSet());
   }
   RunLoop();
 
   // Nothing uploaded.
   EXPECT_EQ(0U, uploader()->upload_requests.size());
   // See that the delegate was never called.
   ASSERT_EQ(0U, on_attachment_uploaded_list().size());
 }
@@ skipping 13 matching lines @@
 
 // Upload three attachments.  For one of them, server responds with error.
 TEST_F(AttachmentServiceImplTest, UploadAttachments_OneUploadFails) {
   AttachmentIdSet attachment_ids;
   const unsigned num_attachments = 3;
   for (unsigned i = 0; i < num_attachments; ++i) {
     attachment_ids.insert(AttachmentId::Create());
   }
   attachment_service()->UploadAttachments(attachment_ids);
 
-  for (unsigned i = 0; i < num_attachments; ++i) {
-    RunLoop();
-    ASSERT_GE(1U, store()->read_ids.size());
+  for (unsigned i = 0; i < 3; ++i) {
+    RunLoopAndFireTimer();
+    ASSERT_GE(store()->read_ids.size(), 1U);
     store()->RespondToRead(attachment_ids);
     RunLoop();
     ASSERT_EQ(1U, uploader()->upload_requests.size());
     AttachmentUploader::UploadResult result =
         AttachmentUploader::UPLOAD_SUCCESS;
     // Fail the 2nd one.
     if (i == 2U) {
       result = AttachmentUploader::UPLOAD_UNSPECIFIED_ERROR;
     } else {
       result = AttachmentUploader::UPLOAD_SUCCESS;
     }
     uploader()->RespondToUpload(uploader()->upload_requests.begin()->first,
                                 result);
+    RunLoop();
   }
-  RunLoop();
   ASSERT_EQ(2U, on_attachment_uploaded_list().size());
 }
 
+// Attempt an upload, respond with transient error to trigger backoff, issue
+// network disconnect/connect events and see that backoff is cleared.
+TEST_F(AttachmentServiceImplTest,
+       UploadAttachments_ResetBackoffAfterNetworkChange) {
+  AttachmentIdSet attachment_ids;
+  attachment_ids.insert(AttachmentId::Create());
+  attachment_service()->UploadAttachments(attachment_ids);
+
+  RunLoopAndFireTimer();
+  ASSERT_EQ(1U, store()->read_ids.size());
+  store()->RespondToRead(attachment_ids);
+  RunLoop();
+  ASSERT_EQ(1U, uploader()->upload_requests.size());
+
+  uploader()->RespondToUpload(uploader()->upload_requests.begin()->first,
+                              AttachmentUploader::UPLOAD_TRANSIENT_ERROR);
+  RunLoop();
+
+  // See that we are in backoff.
+  ASSERT_TRUE(mock_timer()->IsRunning());
+  ASSERT_GT(mock_timer()->GetCurrentDelay(), base::TimeDelta());
+
+  // Issue a network disconnect event.
+  network_change_notifier()->NotifyObserversOfNetworkChangeForTests(
+      net::NetworkChangeNotifier::CONNECTION_NONE);
+  RunLoop();
+
+  // Still in backoff.
+  ASSERT_TRUE(mock_timer()->IsRunning());
+  ASSERT_GT(mock_timer()->GetCurrentDelay(), base::TimeDelta());
+
+  // Issue a network connect event.
+  net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
+      net::NetworkChangeNotifier::CONNECTION_WIFI);
+  RunLoop();
+
+  // No longer in backoff.
+  ASSERT_TRUE(mock_timer()->IsRunning());
+  ASSERT_EQ(base::TimeDelta(), mock_timer()->GetCurrentDelay());
+}
+
 }  // namespace syncer