Move chrome/common/net/notifier to jingle/notifier so that it can be used by remoting/remoting.gyp.

BUG=none
TEST=compiles

Review URL: http://codereview.chromium.org/2885005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@51216 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 339 insertions, 0 deletions

diff --git a/jingle/notifier/base/signal_thread_task.h b/jingle/notifier/base/signal_thread_task.h
new file mode 100644
index 0000000..8a6ff27
--- /dev/null
+++ b/jingle/notifier/base/signal_thread_task.h
@@ -0,0 +1,96 @@
+// Copyright (c) 2009 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.
+
+#ifndef JINGLE_NOTIFIER_BASE_SIGNAL_THREAD_TASK_H_
+#define JINGLE_NOTIFIER_BASE_SIGNAL_THREAD_TASK_H_
+
+#include "base/logging.h"
+#include "talk/base/common.h"
+#include "talk/base/signalthread.h"
+#include "talk/base/sigslot.h"
+#include "talk/base/task.h"
+
+namespace notifier {
+
+template<class T>
+class SignalThreadTask : public talk_base::Task,
+                         public sigslot::has_slots<> {
+ public:
+  // Takes ownership of signal_thread.
+  SignalThreadTask(talk_base::Task* task_parent, T** signal_thread)
+    : talk_base::Task(task_parent),
+      signal_thread_(NULL),
+      finished_(false) {
+    SetSignalThread(signal_thread);
+  }
+
+  virtual ~SignalThreadTask() {
+    ClearSignalThread();
+  }
+
+  virtual void Stop() {
+    Task::Stop();
+    ClearSignalThread();
+  }
+
+  virtual int ProcessStart() {
+    DCHECK_EQ(GetState(), talk_base::Task::STATE_START);
+    signal_thread_->SignalWorkDone.connect(
+        this,
+        &SignalThreadTask<T>::OnWorkDone);
+    signal_thread_->Start();
+    return talk_base::Task::STATE_RESPONSE;
+  }
+
+  int ProcessResponse() {
+    if (!finished_) {
+      return talk_base::Task::STATE_BLOCKED;
+    }
+    SignalWorkDone(signal_thread_);
+    ClearSignalThread();
+    return talk_base::Task::STATE_DONE;
+  }
+
+  sigslot::signal1<T*> SignalWorkDone;
+
+ private:
+  // Takes ownership of signal_thread.
+  void SetSignalThread(T** signal_thread) {
+    DCHECK(!signal_thread_);
+    DCHECK(signal_thread);
+    DCHECK(*signal_thread);
+    // No one should be listening to the signal thread for work done.
+    // They should be using this class instead.  Unfortunately, we
+    // can't verify this.
+
+    signal_thread_ = *signal_thread;
+
+    // Helps callers not to use signal thread after this point since this class
+    // has taken ownership (and avoid the error of doing
+    // signal_thread->Start()).
+    *signal_thread = NULL;
+  }
+
+  void OnWorkDone(talk_base::SignalThread* signal_thread) {
+    DCHECK_EQ(signal_thread, signal_thread_);
+    finished_ = true;
+    Wake();
+  }
+
+  void ClearSignalThread() {
+    if (signal_thread_) {
+      // Don't wait on the thread destruction, or we may deadlock.
+      signal_thread_->Destroy(false);
+      signal_thread_ = NULL;
+    }
+  }
+
+  T* signal_thread_;
+  bool finished_;
+  DISALLOW_COPY_AND_ASSIGN(SignalThreadTask);
+};
+
+}  // namespace notifier
+
+#endif  // JINGLE_NOTIFIER_BASE_SIGNAL_THREAD_TASK_H_
diff --git a/jingle/notifier/base/sigslotrepeater.h b/jingle/notifier/base/sigslotrepeater.h
new file mode 100644
index 0000000..cafb491
--- /dev/null
+++ b/jingle/notifier/base/sigslotrepeater.h
@@ -0,0 +1,83 @@
+// Copyright (c) 2009 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.
+
+#ifndef JINGLE_NOTIFIER_BASE_SIGSLOTREPEATER_H_
+#define JINGLE_NOTIFIER_BASE_SIGSLOTREPEATER_H_
+
+// Repeaters are both signals and slots, which are designed as intermediate
+// pass-throughs for signals and slots which don't know about each other (for
+// modularity or encapsulation).  This eliminates the need to declare a signal
+// handler whose sole purpose is to fire another signal.  The repeater connects
+// to the originating signal using the 'repeat' method.  When the repeated
+// signal fires, the repeater will also fire.
+
+#include "talk/base/sigslot.h"
+
+namespace sigslot {
+
+template<class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+class repeater0 : public signal0<mt_policy>,
+                  public has_slots<mt_policy> {
+ public:
+  typedef signal0<mt_policy> base_type;
+  typedef repeater0<mt_policy> this_type;
+
+  repeater0() { }
+  explicit repeater0(const this_type& s) : base_type(s) { }
+
+  void reemit() { signal0<mt_policy>::emit(); }
+  void repeat(base_type &s) { s.connect(this, &this_type::reemit); }
+};
+
+template<class arg1_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+class repeater1 : public signal1<arg1_type, mt_policy>,
+                  public has_slots<mt_policy> {
+ public:
+  typedef signal1<arg1_type, mt_policy> base_type;
+  typedef repeater1<arg1_type, mt_policy> this_type;
+
+  repeater1() { }
+  repeater1(const this_type& s) : base_type(s) { }
+
+  void reemit(arg1_type a1) { signal1<arg1_type, mt_policy>::emit(a1); }
+  void repeat(base_type& s) { s.connect(this, &this_type::reemit); }
+};
+
+template<class arg1_type, class arg2_type,
+         class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+class repeater2 : public signal2<arg1_type, arg2_type, mt_policy>,
+                  public has_slots<mt_policy> {
+ public:
+  typedef signal2<arg1_type, arg2_type, mt_policy> base_type;
+  typedef repeater2<arg1_type, arg2_type, mt_policy> this_type;
+
+  repeater2() { }
+  repeater2(const this_type& s) : base_type(s) { }
+
+  void reemit(arg1_type a1, arg2_type a2) {
+    signal2<arg1_type, arg2_type, mt_policy>::emit(a1, a2);
+  }
+  void repeat(base_type& s) { s.connect(this, &this_type::reemit); }
+};
+
+template<class arg1_type, class arg2_type, class arg3_type,
+         class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+class repeater3 : public signal3<arg1_type, arg2_type, arg3_type, mt_policy>,
+                  public has_slots<mt_policy> {
+ public:
+  typedef signal3<arg1_type, arg2_type, arg3_type, mt_policy> base_type;
+  typedef repeater3<arg1_type, arg2_type, arg3_type, mt_policy> this_type;
+
+  repeater3() { }
+  repeater3(const this_type& s) : base_type(s) { }
+
+  void reemit(arg1_type a1, arg2_type a2, arg3_type a3) {
+    signal3<arg1_type, arg2_type, arg3_type, mt_policy>::emit(a1, a2, a3);
+  }
+  void repeat(base_type& s) { s.connect(this, &this_type::reemit); }
+};
+
+}  // namespace sigslot
+
+#endif  // JINGLE_NOTIFIER_BASE_SIGSLOTREPEATER_H_
diff --git a/jingle/notifier/base/ssl_adapter.cc b/jingle/notifier/base/ssl_adapter.cc
new file mode 100644
index 0000000..2111244
--- /dev/null
+++ b/jingle/notifier/base/ssl_adapter.cc
@@ -0,0 +1,27 @@
+// Copyright (c) 2009 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 "jingle/notifier/base/ssl_adapter.h"
+
+#if defined(OS_WIN)
+#include "talk/base/ssladapter.h"
+#else
+#include "jingle/notifier/communicator/ssl_socket_adapter.h"
+#endif
+
+namespace notifier {
+
+talk_base::SSLAdapter* CreateSSLAdapter(talk_base::AsyncSocket* socket) {
+  talk_base::SSLAdapter* ssl_adapter =
+#if defined(OS_WIN)
+      talk_base::SSLAdapter::Create(socket);
+#else
+      notifier::SSLSocketAdapter::Create(socket);
+#endif
+  DCHECK(ssl_adapter);
+  return ssl_adapter;
+}
+
+}  // namespace notifier
+
diff --git a/jingle/notifier/base/ssl_adapter.h b/jingle/notifier/base/ssl_adapter.h
new file mode 100644
index 0000000..32517cd
--- /dev/null
+++ b/jingle/notifier/base/ssl_adapter.h
@@ -0,0 +1,33 @@
+// Copyright (c) 2009 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.
+
+#ifndef JINGLE_NOTIFIER_BASE_SSL_ADAPTER_H_
+#define JINGLE_NOTIFIER_BASE_SSL_ADAPTER_H_
+
+namespace talk_base {
+class AsyncSocket;
+class SSLAdapter;
+}  // namespace talk_base
+
+namespace notifier {
+
+// Wraps the given socket in a platform-dependent SSLAdapter
+// implementation.
+talk_base::SSLAdapter* CreateSSLAdapter(talk_base::AsyncSocket* socket);
+
+// Utility template class that overrides CreateSSLAdapter() to use the
+// above function.
+template <class SocketFactory>
+class SSLAdapterSocketFactory : public SocketFactory {
+ public:
+  virtual talk_base::SSLAdapter* CreateSSLAdapter(
+      talk_base::AsyncSocket* socket) {
+    return ::notifier::CreateSSLAdapter(socket);
+  }
+};
+
+}  // namespace notifier
+
+#endif  // JINGLE_NOTIFIER_BASE_SSL_ADAPTER_H_
+
diff --git a/jingle/notifier/base/static_assert.h b/jingle/notifier/base/static_assert.h
new file mode 100644
index 0000000..58a8fe4
--- /dev/null
+++ b/jingle/notifier/base/static_assert.h
@@ -0,0 +1,21 @@
+// Copyright (c) 2009 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.
+
+#ifndef JINGLE_NOTIFIER_BASE_STATIC_ASSERT_H_
+#define JINGLE_NOTIFIER_BASE_STATIC_ASSERT_H_
+
+template<bool> struct STATIC_ASSERTION_FAILURE;
+
+template<> struct STATIC_ASSERTION_FAILURE<true> {
+  enum { value = 1 };
+};
+
+template<int> struct static_assert_test{};
+
+#define STATIC_ASSERT(B) \
+typedef static_assert_test<\
+  sizeof(STATIC_ASSERTION_FAILURE< (bool)( B ) >)>\
+    static_assert_typedef_ ##  __LINE__
+
+#endif  // JINGLE_NOTIFIER_BASE_STATIC_ASSERT_H_
diff --git a/jingle/notifier/base/task_pump.cc b/jingle/notifier/base/task_pump.cc
new file mode 100644
index 0000000..52ffd26
--- /dev/null
+++ b/jingle/notifier/base/task_pump.cc
@@ -0,0 +1,45 @@
+// Copyright (c) 2009 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 "base/message_loop.h"
+#include "jingle/notifier/base/task_pump.h"
+
+namespace notifier {
+
+TaskPump::TaskPump()
+    : scoped_runnable_method_factory_(
+        ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      posted_wake_(false) {}
+
+TaskPump::~TaskPump() {}
+
+void TaskPump::WakeTasks() {
+  if (!posted_wake_) {
+    // Do the requested wake up.
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        scoped_runnable_method_factory_.NewRunnableMethod(
+            &TaskPump::CheckAndRunTasks));
+    posted_wake_ = true;
+  }
+}
+
+int64 TaskPump::CurrentTime() {
+  // Only timeout tasks rely on this function.  Since we're not using
+  // libjingle tasks for timeout, it's safe to return 0 here.
+  return 0;
+}
+
+void TaskPump::CheckAndRunTasks() {
+  posted_wake_ = false;
+  // We shouldn't be using libjingle for timeout tasks, so we should
+  // have no timeout tasks at all.
+
+  // TODO(akalin): Add HasTimeoutTask() back in TaskRunner class and
+  // uncomment this check.
+  // DCHECK(!HasTimeoutTask())
+  RunTasks();
+}
+
+}  // namespace notifier
diff --git a/jingle/notifier/base/task_pump.h b/jingle/notifier/base/task_pump.h
new file mode 100644
index 0000000..806fed2
--- /dev/null
+++ b/jingle/notifier/base/task_pump.h
@@ -0,0 +1,34 @@
+// Copyright (c) 2009 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.
+
+#ifndef JINGLE_NOTIFIER_BASE_TASK_PUMP_H_
+#define JINGLE_NOTIFIER_BASE_TASK_PUMP_H_
+
+#include "base/task.h"
+#include "talk/base/taskrunner.h"
+
+namespace notifier {
+
+class TaskPump : public talk_base::TaskRunner {
+ public:
+  TaskPump();
+
+  virtual ~TaskPump();
+
+  // talk_base::TaskRunner implementation.
+  virtual void WakeTasks();
+  virtual int64 CurrentTime();
+
+ private:
+  void CheckAndRunTasks();
+
+  ScopedRunnableMethodFactory<TaskPump> scoped_runnable_method_factory_;
+  bool posted_wake_;
+
+  DISALLOW_COPY_AND_ASSIGN(TaskPump);
+};
+
+}  // namespace notifier
+
+#endif  // JINGLE_NOTIFIER_BASE_TASK_PUMP_H_