[Sync] Remove ScopedServerStatusWatcher

sync/engine/syncer_proto_util_unittest.cc

 // Copyright (c) 2012 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/engine/syncer_proto_util.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 16 matching lines @@
 using sync_pb::ClientToServerMessage;
 using sync_pb::CommitResponse_EntryResponse;
 using sync_pb::SyncEntity;
 
 namespace syncer {
 
 using sessions::SyncSessionContext;
 
 class MockDelegate : public sessions::SyncSession::Delegate {
  public:
-   MockDelegate() {}
-   ~MockDelegate() {}
+  MockDelegate() {}
+  ~MockDelegate() {}
 
   MOCK_METHOD1(OnReceivedShortPollIntervalUpdate, void(const base::TimeDelta&));
-  MOCK_METHOD1(OnReceivedLongPollIntervalUpdate ,void(const base::TimeDelta&));
+  MOCK_METHOD1(OnReceivedLongPollIntervalUpdate, void(const base::TimeDelta&));
   MOCK_METHOD1(OnReceivedSessionsCommitDelay, void(const base::TimeDelta&));
   MOCK_METHOD1(OnReceivedClientInvalidationHintBufferSize, void(int));
   MOCK_METHOD1(OnSyncProtocolError, void(const SyncProtocolError&));
 };
 
 // Builds a ClientToServerResponse with some data type ids, including
 // invalid ones.  GetTypesToMigrate() should return only the valid
 // model types.
 TEST(SyncerProtoUtil, GetTypesToMigrate) {
   sync_pb::ClientToServerResponse response;
@@ skipping 166 matching lines @@
   SyncerProtoUtil::AddRequestBirthday(directory(), &msg);
   EXPECT_FALSE(msg.has_store_birthday());
 
   directory()->set_store_birthday("meat");
   SyncerProtoUtil::AddRequestBirthday(directory(), &msg);
   EXPECT_EQ(msg.store_birthday(), "meat");
 }
 
 class DummyConnectionManager : public ServerConnectionManager {
  public:
-  DummyConnectionManager(CancelationSignal* signal)
+  explicit DummyConnectionManager(CancelationSignal* signal)
       : ServerConnectionManager("unused", 0, false, signal),
-        send_error_(false),
-        access_denied_(false) {}
+        send_error_(false) {}
 
   ~DummyConnectionManager() override {}
-  bool PostBufferWithCachedAuth(PostBufferParams* params,
-                                ScopedServerStatusWatcher* watcher) override {
+  bool PostBufferWithCachedAuth(PostBufferParams* params) override {
     if (send_error_) {
       return false;
     }
 
     sync_pb::ClientToServerResponse response;
-    if (access_denied_) {
-      response.set_error_code(sync_pb::SyncEnums::ACCESS_DENIED);
-    }
     response.SerializeToString(&params->buffer_out);
 
     return true;
   }
 
   void set_send_error(bool send) {
     send_error_ = send;
   }
 
-  void set_access_denied(bool denied) {
-    access_denied_ = denied;
-  }
-
  private:
   bool send_error_;
-  bool access_denied_;
 };
 
 TEST_F(SyncerProtoUtilTest, PostAndProcessHeaders) {
   CancelationSignal signal;
   DummyConnectionManager dcm(&signal);
   ClientToServerMessage msg;
   SyncerProtoUtil::SetProtocolVersion(&msg);
   msg.set_share("required");
   msg.set_message_contents(ClientToServerMessage::GET_UPDATES);
   sync_pb::ClientToServerResponse response;
 
   dcm.set_send_error(true);
   EXPECT_FALSE(SyncerProtoUtil::PostAndProcessHeaders(&dcm, NULL,
       msg, &response));
 
   dcm.set_send_error(false);
   EXPECT_TRUE(SyncerProtoUtil::PostAndProcessHeaders(&dcm, NULL,
       msg, &response));
-
-  dcm.set_access_denied(true);
-  EXPECT_FALSE(SyncerProtoUtil::PostAndProcessHeaders(&dcm, NULL,
-      msg, &response));
 }
 
 }  // namespace syncer