Fixing sigslot copy constructors.

webrtc/base/sigslot_unittest.cc

 /*
  *  Copyright 2012 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 18 matching lines @@
 };
 
 template<class slot_policy = sigslot::single_threaded,
          class signal_policy = sigslot::single_threaded>
 class SigslotReceiver : public sigslot::has_slots<slot_policy> {
  public:
   SigslotReceiver() : signal_(nullptr), signal_count_(0) {}
   ~SigslotReceiver() {
   }
 
+  // Provide copy constructor so that tests can exercise the has_slots copy
+  // constructor.
+  SigslotReceiver(const SigslotReceiver&) = default;
+
   void Connect(sigslot::signal0<signal_policy>* signal) {
     if (!signal) return;
     Disconnect();
     signal_ = signal;
     signal->connect(this,
                     &SigslotReceiver<slot_policy, signal_policy>::OnSignal);
   }
   void Disconnect() {
     if (!signal_) return;
     signal_->disconnect(this);
@@ skipping 166 matching lines @@
 // Test that locks are acquired and released correctly.
 TEST_F(SigslotMTLockTest, LockSanity) {
   const int lock_count = SignalLockCount();
   Signal();
   EXPECT_FALSE(InCriticalSection());
   EXPECT_EQ(lock_count + 1, SignalLockCount());
   EXPECT_EQ(1, signal_count());
 }
 
 // Destroy signal and slot in different orders.
-TEST(DestructionOrder, SignalFirst) {
+TEST(SigslotDestructionOrder, SignalFirst) {
   sigslot::signal0<>* signal = new sigslot::signal0<>;
   SigslotReceiver<>* receiver = new SigslotReceiver<>();
   receiver->Connect(signal);
   (*signal)();
   EXPECT_EQ(1, receiver->signal_count());
   delete signal;
   delete receiver;
 }
 
-TEST(DestructionOrder, SlotFirst) {
+TEST(SigslotDestructionOrder, SlotFirst) {
   sigslot::signal0<>* signal = new sigslot::signal0<>;
   SigslotReceiver<>* receiver = new SigslotReceiver<>();
   receiver->Connect(signal);
   (*signal)();
   EXPECT_EQ(1, receiver->signal_count());
 
   delete receiver;
   (*signal)();
   delete signal;
 }
+
+// Test that if a signal is copied, its slot connections are copied as well.
+TEST(SigslotTest, CopyConnectedSignal) {
+  sigslot::signal<> signal;
+  SigslotReceiver<> receiver;
+  receiver.Connect(&signal);
+
+  // Fire the copied signal, expecting the receiver to be notified.
+  sigslot::signal<> copied_signal(signal);
+  copied_signal();
+  EXPECT_EQ(1, receiver.signal_count());
+}
+
+// Test that if a slot is copied, its signal connections are copied as well.
+TEST(SigslotTest, CopyConnectedSlot) {
+  sigslot::signal<> signal;
+  SigslotReceiver<> receiver;
+  receiver.Connect(&signal);
+
+  // Fire the signal after copying the receiver, expecting the copied receiver
+  // to be notified.
+  SigslotReceiver<> copied_receiver(receiver);
+  signal();
+  EXPECT_EQ(1, copied_receiver.signal_count());
+}