The Tor Browser: ipc/ipdl/test/cxx/TestMultiMgrs.h@8bccb770b82d

     1 #ifndef mozilla__ipdltest_TestMultiMgrs_h

     2 #define mozilla__ipdltest_TestMultiMgrs_h 1

     4 #include "mozilla/_ipdltest/IPDLUnitTests.h"

     6 #include "mozilla/_ipdltest/PTestMultiMgrsParent.h"

     7 #include "mozilla/_ipdltest/PTestMultiMgrsChild.h"

     8 #include "mozilla/_ipdltest/PTestMultiMgrsBottomParent.h"

     9 #include "mozilla/_ipdltest/PTestMultiMgrsBottomChild.h"

    10 #include "mozilla/_ipdltest/PTestMultiMgrsLeftParent.h"

    11 #include "mozilla/_ipdltest/PTestMultiMgrsLeftChild.h"

    12 #include "mozilla/_ipdltest/PTestMultiMgrsRightParent.h"

    13 #include "mozilla/_ipdltest/PTestMultiMgrsRightChild.h"

    15 namespace mozilla {

    16 namespace _ipdltest {

    18 //-----------------------------------------------------------------------------

    19 // Parent side

    20 //

    22 class TestMultiMgrsBottomParent :

    23     public PTestMultiMgrsBottomParent

    24 {

    25 public:

    26     TestMultiMgrsBottomParent() { }

    27     virtual ~TestMultiMgrsBottomParent() { }

    28 };

    30 class TestMultiMgrsLeftParent :

    31     public PTestMultiMgrsLeftParent

    32 {

    33 public:

    34     TestMultiMgrsLeftParent() { }

    35     virtual ~TestMultiMgrsLeftParent() { }

    37     bool HasChild(TestMultiMgrsBottomParent* c)

    38     {

    39         return ManagedPTestMultiMgrsBottomParent().Contains(c);

    40     }

    42 protected:

    43     virtual PTestMultiMgrsBottomParent* AllocPTestMultiMgrsBottomParent() MOZ_OVERRIDE

    44     {

    45         return new TestMultiMgrsBottomParent();

    46     }

    48     virtual bool DeallocPTestMultiMgrsBottomParent(PTestMultiMgrsBottomParent* actor) MOZ_OVERRIDE

    49     {

    50         delete actor;

    51         return true;

    52     }

    53 };

    55 class TestMultiMgrsRightParent :

    56     public PTestMultiMgrsRightParent

    57 {

    58 public:

    59     TestMultiMgrsRightParent() { }

    60     virtual ~TestMultiMgrsRightParent() { }

    62     bool HasChild(TestMultiMgrsBottomParent* c)

    63     {

    64         return ManagedPTestMultiMgrsBottomParent().Contains(c);

    65     }

    67 protected:

    68     virtual PTestMultiMgrsBottomParent* AllocPTestMultiMgrsBottomParent() MOZ_OVERRIDE

    69     {

    70         return new TestMultiMgrsBottomParent();

    71     }

    73     virtual bool DeallocPTestMultiMgrsBottomParent(PTestMultiMgrsBottomParent* actor) MOZ_OVERRIDE

    74     {

    75         delete actor;

    76         return true;

    77     }

    78 };

    80 class TestMultiMgrsParent :

    81     public PTestMultiMgrsParent

    82 {

    83 public:

    84     TestMultiMgrsParent() { }

    85     virtual ~TestMultiMgrsParent() { }

    87     static bool RunTestInProcesses() { return true; }

    88     static bool RunTestInThreads() { return true; }

    90     void Main();

    92 protected:

    93     virtual bool RecvOK() MOZ_OVERRIDE;

    95     virtual PTestMultiMgrsLeftParent* AllocPTestMultiMgrsLeftParent() MOZ_OVERRIDE

    96     {

    97         return new TestMultiMgrsLeftParent();

    98     }

   100     virtual bool DeallocPTestMultiMgrsLeftParent(PTestMultiMgrsLeftParent* actor) MOZ_OVERRIDE

   101     {

   102         delete actor;

   103         return true;

   104     }

   106     virtual PTestMultiMgrsRightParent* AllocPTestMultiMgrsRightParent() MOZ_OVERRIDE

   107     {

   108         return new TestMultiMgrsRightParent();

   109     }

   111     virtual bool DeallocPTestMultiMgrsRightParent(PTestMultiMgrsRightParent* actor) MOZ_OVERRIDE

   112     {

   113         delete actor;

   114         return true;

   115     }

   117     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE

   118     {

   119         if (NormalShutdown != why)

   120             fail("unexpected destruction!");

   121         passed("ok");

   122         QuitParent();

   123     }

   124 };

   126 //-----------------------------------------------------------------------------

   127 // Child side

   128 //

   130 class TestMultiMgrsBottomChild :

   131     public PTestMultiMgrsBottomChild

   132 {

   133 public:

   134     TestMultiMgrsBottomChild() { }

   135     virtual ~TestMultiMgrsBottomChild() { }

   136 };

   138 class TestMultiMgrsLeftChild :

   139     public PTestMultiMgrsLeftChild

   140 {

   141 public:

   142     TestMultiMgrsLeftChild() { }

   143     virtual ~TestMultiMgrsLeftChild() { }

   145     bool HasChild(PTestMultiMgrsBottomChild* c)

   146     {

   147         return ManagedPTestMultiMgrsBottomChild().Contains(c);

   148     }

   150 protected:

   151     virtual bool RecvPTestMultiMgrsBottomConstructor(PTestMultiMgrsBottomChild* actor) MOZ_OVERRIDE;

   153     virtual PTestMultiMgrsBottomChild* AllocPTestMultiMgrsBottomChild() MOZ_OVERRIDE

   154     {

   155         return new TestMultiMgrsBottomChild();

   156     }

   158     virtual bool DeallocPTestMultiMgrsBottomChild(PTestMultiMgrsBottomChild* actor) MOZ_OVERRIDE

   159     {

   160         delete actor;

   161         return true;

   162     }

   163 };

   165 class TestMultiMgrsRightChild :

   166     public PTestMultiMgrsRightChild

   167 {

   168 public:

   169     TestMultiMgrsRightChild() { }

   170     virtual ~TestMultiMgrsRightChild() { }

   172     bool HasChild(PTestMultiMgrsBottomChild* c)

   173     {

   174         return ManagedPTestMultiMgrsBottomChild().Contains(c);

   175     }

   177 protected:

   178     virtual bool RecvPTestMultiMgrsBottomConstructor(PTestMultiMgrsBottomChild* actor) MOZ_OVERRIDE;

   180     virtual PTestMultiMgrsBottomChild* AllocPTestMultiMgrsBottomChild() MOZ_OVERRIDE

   181     {

   182         return new TestMultiMgrsBottomChild();

   183     }

   185     virtual bool DeallocPTestMultiMgrsBottomChild(PTestMultiMgrsBottomChild* actor) MOZ_OVERRIDE

   186     {

   187         delete actor;

   188         return true;

   189     }

   190 };

   192 class TestMultiMgrsChild :

   193     public PTestMultiMgrsChild

   194 {

   195 public:

   196     TestMultiMgrsChild() { }

   197     virtual ~TestMultiMgrsChild() { }

   199     void Main();

   201     PTestMultiMgrsBottomChild* mBottomL;

   202     PTestMultiMgrsBottomChild* mBottomR;

   204 protected:

   205     virtual bool RecvCheck() MOZ_OVERRIDE;

   207     virtual PTestMultiMgrsLeftChild* AllocPTestMultiMgrsLeftChild() MOZ_OVERRIDE

   208     {

   209         return new TestMultiMgrsLeftChild();

   210     }

   212     virtual bool DeallocPTestMultiMgrsLeftChild(PTestMultiMgrsLeftChild* actor) MOZ_OVERRIDE

   213     {

   214         delete actor;

   215         return true;

   216     }

   218     virtual PTestMultiMgrsRightChild* AllocPTestMultiMgrsRightChild() MOZ_OVERRIDE

   219     {

   220         return new TestMultiMgrsRightChild();

   221     }

   223     virtual bool DeallocPTestMultiMgrsRightChild(PTestMultiMgrsRightChild* actor) MOZ_OVERRIDE

   224     {

   225         delete actor;

   226         return true;

   227     }

   229     virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE

   230     {

   231         if (NormalShutdown != why)

   232             fail("unexpected destruction!");

   233         passed("ok");

   234         QuitChild();

   235     }

   236 };

   239 } // namespace _ipdltest

   240 } // namespace mozilla

   243 #endif // ifndef mozilla__ipdltest_TestMultiMgrs_h

The Tor Browser / file revision