Convert Callback to {Once,Repeating}Callback in //jingle.

Use OnceCallback where possible, and use BindRepeating() where it is
meant to be a RepeatingCallback.

TBR=sergeyu@chromium.org

Bug: 1007709
Change-Id: I4408f77d876e5b72017892ebc2195dafabadfccd
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1943048Reviewed-by: danakj <danakj@chromium.org>
Reviewed-by: vmpstr <vmpstr@chromium.org>
Commit-Queue: danakj <danakj@chromium.org>
Cr-Commit-Position: refs/heads/master@{#720028}

PRESUBMIT.py

@@ -384,7 +384,6 @@ _NOT_CONVERTED_TO_MODERN_BIND_AND_CALLBACK = '|'.join((
   '^ios/web/',
   '^ios/web_view/',
   '^ipc/',
-  '^jingle/',
   '^media/audio/',
   '^media/base/',
   '^media/blink/',

jingle/glue/fake_ssl_client_socket.cc

@@ -194,8 +194,8 @@ void FakeSSLClientSocket::DoHandshakeLoopWithUserConnectCallback() {
 }
 
 int FakeSSLClientSocket::DoConnect() {
-  int status = transport_socket_->Connect(
-      base::Bind(&FakeSSLClientSocket::OnConnectDone, base::Unretained(this)));
+  int status = transport_socket_->Connect(base::BindOnce(
+      &FakeSSLClientSocket::OnConnectDone, base::Unretained(this)));
   if (status != net::OK) {
     return status;
   }
@@ -224,8 +224,8 @@ void FakeSSLClientSocket::ProcessConnectDone() {
 int FakeSSLClientSocket::DoSendClientHello() {
   int status = transport_socket_->Write(
       write_buf_.get(), write_buf_->BytesRemaining(),
-      base::Bind(&FakeSSLClientSocket::OnSendClientHelloDone,
-                 base::Unretained(this)),
+      base::BindOnce(&FakeSSLClientSocket::OnSendClientHelloDone,
+                     base::Unretained(this)),
       TRAFFIC_ANNOTATION_FOR_TESTS);
   if (status < net::OK) {
     return status;
@@ -258,10 +258,9 @@ void FakeSSLClientSocket::ProcessSendClientHelloDone(size_t written) {
 
 int FakeSSLClientSocket::DoVerifyServerHello() {
   int status = transport_socket_->Read(
-      read_buf_.get(),
-      read_buf_->BytesRemaining(),
-      base::Bind(&FakeSSLClientSocket::OnVerifyServerHelloDone,
-                 base::Unretained(this)));
+      read_buf_.get(), read_buf_->BytesRemaining(),
+      base::BindOnce(&FakeSSLClientSocket::OnVerifyServerHelloDone,
+                     base::Unretained(this)));
   if (status < net::OK) {
     return status;
   }

jingle/notifier/listener/non_blocking_push_client.cc

@@ -30,8 +30,7 @@ class NonBlockingPushClient::Core
   // This is separated out from the constructor since posting tasks
   // from the constructor is dangerous.
   void CreateOnDelegateThread(
-      const CreateBlockingPushClientCallback&
-          create_blocking_push_client_callback);
+      CreateBlockingPushClientCallback create_blocking_push_client_callback);
 
   // Must be called before being destroyed.
   void DestroyOnDelegateThread();
@@ -78,11 +77,10 @@ NonBlockingPushClient::Core::~Core() {
 }
 
 void NonBlockingPushClient::Core::CreateOnDelegateThread(
-    const CreateBlockingPushClientCallback&
-        create_blocking_push_client_callback) {
+    CreateBlockingPushClientCallback create_blocking_push_client_callback) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   DCHECK(!delegate_push_client_.get());
-  delegate_push_client_ = create_blocking_push_client_callback.Run();
+  delegate_push_client_ = std::move(create_blocking_push_client_callback).Run();
   delegate_push_client_->AddObserver(this);
 }
 
@@ -154,14 +152,13 @@ void NonBlockingPushClient::Core::OnPingResponse() {
 
 NonBlockingPushClient::NonBlockingPushClient(
     const scoped_refptr<base::SingleThreadTaskRunner>& delegate_task_runner,
-    const CreateBlockingPushClientCallback&
-        create_blocking_push_client_callback)
+    CreateBlockingPushClientCallback create_blocking_push_client_callback)
     : delegate_task_runner_(delegate_task_runner) {
   core_ = new Core(delegate_task_runner_, weak_ptr_factory_.GetWeakPtr());
   delegate_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(&NonBlockingPushClient::Core::CreateOnDelegateThread,
-                     core_, create_blocking_push_client_callback));
+                     core_, std::move(create_blocking_push_client_callback)));
 }
 
 NonBlockingPushClient::~NonBlockingPushClient() {

jingle/notifier/listener/non_blocking_push_client.h

@@ -31,15 +31,14 @@ class NonBlockingPushClient : public PushClient {
  public:
   // The type for a function that creates a (blocking) PushClient.
   // Will be called on the delegate task runner.
-  typedef base::Callback<std::unique_ptr<PushClient>()>
-      CreateBlockingPushClientCallback;
+  using CreateBlockingPushClientCallback =
+      base::OnceCallback<std::unique_ptr<PushClient>()>;
 
   // Runs the given callback on the given task runner, and delegates
   // to that PushClient.
   explicit NonBlockingPushClient(
       const scoped_refptr<base::SingleThreadTaskRunner>& delegate_task_runner,
-      const CreateBlockingPushClientCallback&
-          create_blocking_push_client_callback);
+      CreateBlockingPushClientCallback create_blocking_push_client_callback);
   ~NonBlockingPushClient() override;
 
   // PushClient implementation.

jingle/notifier/listener/non_blocking_push_client_unittest.cc

@@ -31,11 +31,10 @@ class NonBlockingPushClientTest : public testing::Test {
   ~NonBlockingPushClientTest() override {}
 
   void SetUp() override {
-    push_client_.reset(
-        new NonBlockingPushClient(
-            base::ThreadTaskRunnerHandle::Get(),
-            base::Bind(&NonBlockingPushClientTest::CreateFakePushClient,
-                       base::Unretained(this))));
+    push_client_ = std::make_unique<NonBlockingPushClient>(
+        base::ThreadTaskRunnerHandle::Get(),
+        base::BindOnce(&NonBlockingPushClientTest::CreateFakePushClient,
+                       base::Unretained(this)));
     push_client_->AddObserver(&fake_observer_);
     // Pump message loop to run CreateFakePushClient.
     base::RunLoop().RunUntilIdle();
@@ -54,10 +53,11 @@ class NonBlockingPushClientTest : public testing::Test {
   std::unique_ptr<PushClient> CreateFakePushClient() {
     if (fake_push_client_) {
       ADD_FAILURE();
-      return std::unique_ptr<PushClient>();
+      return nullptr;
     }
-    fake_push_client_ = new FakePushClient();
-    return std::unique_ptr<PushClient>(fake_push_client_);
+    auto client = std::make_unique<FakePushClient>();
+    fake_push_client_ = client.get();
+    return client;
   }
 
   base::test::SingleThreadTaskEnvironment task_environment_;

jingle/notifier/listener/push_client.cc

@@ -26,9 +26,9 @@ std::unique_ptr<PushClient> CreateXmppPushClient(
 
 std::unique_ptr<PushClient> PushClient::CreateDefault(
     const NotifierOptions& notifier_options) {
-  return std::unique_ptr<PushClient>(new NonBlockingPushClient(
+  return std::make_unique<NonBlockingPushClient>(
       notifier_options.network_config.task_runner,
-      base::Bind(&CreateXmppPushClient, notifier_options)));
+      base::BindOnce(&CreateXmppPushClient, notifier_options));
 }
 
 std::unique_ptr<PushClient> PushClient::CreateDefaultOnIOThread(