Delete Session and SessionManager object synchronously.

remoting/protocol/fake_authenticator.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 "remoting/protocol/fake_authenticator.h"
 
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
+#include "net/base/io_buffer.h"
 #include "net/socket/stream_socket.h"
 #include "remoting/base/constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 
 namespace remoting {
 namespace protocol {
 
 FakeChannelAuthenticator::FakeChannelAuthenticator(bool accept, bool async)
     : accept_(accept),
       async_(async),
+      error_(net::OK),
+      read_(false),
+      written_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 FakeChannelAuthenticator::~FakeChannelAuthenticator() {
 }
 
 void FakeChannelAuthenticator::SecureAndAuthenticate(
     scoped_ptr<net::StreamSocket> socket,
     const DoneCallback& done_callback) {
-  net::Error error;
+  socket_ = socket.Pass();
 
   if (accept_) {
-    error = net::OK;
+    error_ = net::OK;
   } else {
-    error = net::ERR_FAILED;
-    socket.reset();
+    error_ = net::ERR_FAILED;

[Wez, 2012/02/22 22:51:38]

nit: Now that |error_| is a member, you could rename it to |result_| and get rid
of |accept_|.

[Sergey Ulanov, 2012/02/22 23:36:32]

Done.

   }
 
   if (async_) {
-    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        &FakeChannelAuthenticator::CallCallback, weak_factory_.GetWeakPtr(),
-        done_callback, error, base::Passed(&socket)));
+    done_callback_ = done_callback;
+
+    scoped_refptr<net::IOBuffer> write_buf = new net::IOBuffer(1);
+    write_buf->data()[0] = 0;
+    int result = socket_->Write(
+        write_buf, 1, base::Bind(&FakeChannelAuthenticator::OnAuthBytesWritten,
+                                 base::Unretained(this)));

[Wez, 2012/02/22 22:51:38]

Why not continue to use |weak_factory_| here?

[Sergey Ulanov, 2012/02/22 23:36:32]

It is not necessary because socket_ will be deleted before this object unless
these calls are complete. Using weak pointers would require making this class
SupportsWeakPtr<>

[Wez, 2012/02/23 19:33:42]

The old code was using a |weak_factory_| member, so I don't think you'd need
SupportsWeakPtr<>, would you?

[Sergey Ulanov, 2012/02/23 22:10:06]

You are right, changed it to use weak_factory_

+    if (result != net::ERR_IO_PENDING)
+      OnAuthBytesWritten(result);

[Wez, 2012/02/22 22:51:38]

nit: At this point |read_| is never true, so we can't possibly invoke the done
callback, so we're not assuming anything about its behaviour here, but that's
not obvious on a first glance.

[Sergey Ulanov, 2012/02/22 23:36:32]

Added comment.

+
+    scoped_refptr<net::IOBuffer> read_buf = new net::IOBuffer(1);
+    result = socket_->Read(
+        read_buf, 1, base::Bind(&FakeChannelAuthenticator::OnAuthBytesRead,
+                                base::Unretained(this)));
+    if (result != net::ERR_IO_PENDING)
+      OnAuthBytesRead(result);
   } else {
-    done_callback.Run(error, socket.Pass());
+    if (error_ != net::OK)
+      socket_.reset();
+    done_callback.Run(error_, socket_.Pass());
   }
 }
 
-void FakeChannelAuthenticator::CallCallback(
-    const DoneCallback& done_callback,
-    net::Error error,
-    scoped_ptr<net::StreamSocket> socket) {
-  done_callback.Run(error, socket.Pass());
+void FakeChannelAuthenticator::OnAuthBytesWritten(int result) {
+  EXPECT_EQ(1, result);
+  EXPECT_FALSE(written_);
+  written_ = true;
+  if (read_)
+    done_callback_.Run(error_, socket_.Pass());
+}
+
+void FakeChannelAuthenticator::OnAuthBytesRead(int result) {
+  EXPECT_EQ(1, result);
+  EXPECT_FALSE(read_);
+  read_ = true;
+  if (written_)
+    done_callback_.Run(error_, socket_.Pass());
 }
 
 FakeAuthenticator::FakeAuthenticator(
     Type type, int round_trips, Action action, bool async)
     : type_(type),
       round_trips_(round_trips),
       action_(action),
       async_(async),
       messages_(0) {
 }
@@ skipping 72 matching lines @@
 
 scoped_ptr<Authenticator> FakeHostAuthenticatorFactory::CreateAuthenticator(
     const std::string& remote_jid,
     const buzz::XmlElement* first_message) {
   return scoped_ptr<Authenticator>(new FakeAuthenticator(
       FakeAuthenticator::HOST, round_trips_, action_, async_));
 }
 
 }  // namespace protocol
 }  // namespace remoting