The Tor Browser: media/mtransport/test/runnable_utils_unittest.cpp@97036ab72558 (annotated)

media/mtransport/test/runnable_utils_unittest.cpp@97036ab72558 (annotated)

media/mtransport/test/runnable_utils_unittest.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 // Original author: ekr@rtfm.com
 #include <iostream>
 #include "prio.h"
 #include "nsCOMPtr.h"
 #include "nsNetCID.h"
 #include "nsXPCOM.h"
 #include "nsXPCOMGlue.h"
 #include "mozilla/RefPtr.h"
 #include "nsIComponentManager.h"
 #include "nsIComponentRegistrar.h"
 #include "nsIIOService.h"
 #include "nsIServiceManager.h"
 #include "nsISocketTransportService.h"
 #include "nsASocketHandler.h"
 #include "nsServiceManagerUtils.h"
 #include "nsThreadUtils.h"
 #include "runnable_utils.h"
 #include "mtransport_test_utils.h"
 #define GTEST_HAS_RTTI 0
 #include "gtest/gtest.h"
 #include "gtest_utils.h"
 using namespace mozilla;
 MtransportTestUtils *test_utils;
 namespace {
 class Destructor {
  public:
   Destructor(bool* destroyed) : destroyed_(destroyed) {}
   ~Destructor() {
     std::cerr << "Destructor called" << std::endl;
     *destroyed_ = true;
   }
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Destructor)
  private:
   bool *destroyed_;
 };
 class TargetClass {
  public:
   TargetClass(int *ran) : ran_(ran) {}
   void m1(int x) {
     std::cerr << __FUNCTION__ << " " << x << std::endl;
     *ran_ = 1;
   }
   void m2(int x, int y) {
     std::cerr << __FUNCTION__ << " " << x << " " << y << std::endl;
     *ran_ = 2;
   }
   void m1set(bool *z) {
     std::cerr << __FUNCTION__ << std::endl;
     *z = true;
   }
   int return_int(int x) {
     std::cerr << __FUNCTION__ << std::endl;
     return x;
   }
   void destructor_target(Destructor*) {
   }
   void destructor_target_ref(RefPtr<Destructor> destructor) {
   }
   int *ran_;
 };
 class RunnableArgsTest : public ::testing::Test {
  public:
   RunnableArgsTest() : ran_(0), cl_(&ran_){}
   void Test1Arg() {
     nsRunnable * r = WrapRunnable(&cl_, &TargetClass::m1, 1);
     r->Run();
     ASSERT_EQ(1, ran_);
   }
   void Test2Args() {
     nsRunnable* r = WrapRunnable(&cl_, &TargetClass::m2, 1, 2);
     r->Run();
     ASSERT_EQ(2, ran_);
   }
  private:
   int ran_;
   TargetClass cl_;
 };
 class DispatchTest : public ::testing::Test {
  public:
   DispatchTest() : ran_(0), cl_(&ran_) {}
   void SetUp() {
     nsresult rv;
     target_ = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
     ASSERT_TRUE(NS_SUCCEEDED(rv));
   }
   void Test1Arg() {
     nsRunnable* r = WrapRunnable(&cl_, &TargetClass::m1, 1);
     target_->Dispatch(r, NS_DISPATCH_SYNC);
     ASSERT_EQ(1, ran_);
   }
   void Test2Args() {
     nsRunnable* r = WrapRunnable(&cl_, &TargetClass::m2, 1, 2);
     target_->Dispatch(r, NS_DISPATCH_SYNC);
     ASSERT_EQ(2, ran_);
   }
   void Test1Set() {
     bool x = false;
     target_->Dispatch(WrapRunnable(&cl_, &TargetClass::m1set, &x),
                       NS_DISPATCH_SYNC);
     ASSERT_TRUE(x);
   }
   void TestRet() {
     int z;
     int x = 10;
     target_->Dispatch(WrapRunnableRet(&cl_, &TargetClass::return_int, x, &z),
                       NS_DISPATCH_SYNC);
     ASSERT_EQ(10, z);
   }
  protected:
   int ran_;
   TargetClass cl_;
   nsCOMPtr<nsIEventTarget> target_;
 };
 TEST_F(RunnableArgsTest, OneArgument) {
   Test1Arg();
 }
 TEST_F(RunnableArgsTest, TwoArguments) {
   Test2Args();
 }
 TEST_F(DispatchTest, OneArgument) {
   Test1Arg();
 }
 TEST_F(DispatchTest, TwoArguments) {
   Test2Args();
 }
 TEST_F(DispatchTest, Test1Set) {
   Test1Set();
 }
 TEST_F(DispatchTest, TestRet) {
   TestRet();
 }
 void SetNonMethod(TargetClass *cl, int x) {
   cl->m1(x);
 }
 int SetNonMethodRet(TargetClass *cl, int x) {
   cl->m1(x);
   return x;
 }
 TEST_F(DispatchTest, TestNonMethod) {
   test_utils->sts_target()->Dispatch(
       WrapRunnableNM(SetNonMethod, &cl_, 10), NS_DISPATCH_SYNC);
   ASSERT_EQ(1, ran_);
 }
 TEST_F(DispatchTest, TestNonMethodRet) {
   int z;
   test_utils->sts_target()->Dispatch(
       WrapRunnableNMRet(SetNonMethodRet, &cl_, 10, &z), NS_DISPATCH_SYNC);
   ASSERT_EQ(1, ran_);
   ASSERT_EQ(10, z);
 }
 TEST_F(DispatchTest, TestDestructor) {
   bool destroyed = false;
   RefPtr<Destructor> destructor = new Destructor(&destroyed);
   target_->Dispatch(WrapRunnable(&cl_, &TargetClass::destructor_target,
                                  destructor),
                     NS_DISPATCH_SYNC);
   ASSERT_FALSE(destroyed);
   destructor = nullptr;
   ASSERT_TRUE(destroyed);
 }
 TEST_F(DispatchTest, TestDestructorRef) {
   bool destroyed = false;
   RefPtr<Destructor> destructor = new Destructor(&destroyed);
   target_->Dispatch(WrapRunnable(&cl_, &TargetClass::destructor_target_ref,
                                  destructor),
                     NS_DISPATCH_SYNC);
   ASSERT_FALSE(destroyed);
   destructor = nullptr;
   ASSERT_TRUE(destroyed);
 }
 } // end of namespace
 int main(int argc, char **argv) {
   test_utils = new MtransportTestUtils();
   // Start the tests
   ::testing::InitGoogleTest(&argc, argv);
   int rv = RUN_ALL_TESTS();
   delete test_utils;
   return rv;
 }

The Tor Browser / annotate

media/mtransport/test/runnable_utils_unittest.cpp@97036ab72558 (annotated)

media/mtransport/test/runnable_utils_unittest.cpp