summaryrefslogtreecommitdiffstats
path: root/netwerk/ipc/NeckoCommon.h
blob: ed92ac25ea70b608fa1328fcbb9c5e260241bec4 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 ts=8 et 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/. */

#ifndef mozilla_net_NeckoCommon_h
#define mozilla_net_NeckoCommon_h

#include "nsXULAppAPI.h"
#include "prenv.h"
#include "nsPrintfCString.h"
#include "mozilla/Preferences.h"

namespace mozilla { namespace dom {
class TabChild;
} // namespace dom
} // namespace mozilla

#if defined(DEBUG)
# define NECKO_ERRORS_ARE_FATAL_DEFAULT true
#else
# define NECKO_ERRORS_ARE_FATAL_DEFAULT false
#endif 

// TODO: Eventually remove NECKO_MAYBE_ABORT and DROP_DEAD (bug 575494).
// Still useful for catching listener interfaces we don't yet support across
// processes, etc.

#define NECKO_MAYBE_ABORT(msg)                                                 \
  do {                                                                         \
    bool abort = NECKO_ERRORS_ARE_FATAL_DEFAULT;                               \
    const char *e = PR_GetEnv("NECKO_ERRORS_ARE_FATAL");                       \
    if (e)                                                                     \
      abort = (*e == '0') ? false : true;                                      \
    if (abort) {                                                               \
      msg.Append(" (set NECKO_ERRORS_ARE_FATAL=0 in your environment to "      \
                      "convert this error into a warning.)");                  \
      NS_RUNTIMEABORT(msg.get());                                              \
    } else {                                                                   \
      msg.Append(" (set NECKO_ERRORS_ARE_FATAL=1 in your environment to "      \
                      "convert this warning into a fatal error.)");            \
      NS_WARNING(msg.get());                                                   \
    }                                                                          \
  } while (0)

#define DROP_DEAD()                                                            \
  do {                                                                         \
    nsPrintfCString msg("NECKO ERROR: '%s' UNIMPLEMENTED",                     \
                        __FUNCTION__);                                         \
    NECKO_MAYBE_ABORT(msg);                                                    \
    return NS_ERROR_NOT_IMPLEMENTED;                                           \
  } while (0)

#define ENSURE_CALLED_BEFORE_ASYNC_OPEN()                                      \
  do {                                                                         \
    if (mIsPending || mWasOpened) {                                            \
      nsPrintfCString msg("'%s' called after AsyncOpen: %s +%d",               \
                          __FUNCTION__, __FILE__, __LINE__);                   \
      NECKO_MAYBE_ABORT(msg);                                                  \
    }                                                                          \
    NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS);                         \
    NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED);                      \
  } while (0)

// Fails call if made after request observers (on-modify-request, etc) have been
// called

#define ENSURE_CALLED_BEFORE_CONNECT()                                         \
  do {                                                                         \
    if (mRequestObserversCalled) {                                             \
      nsPrintfCString msg("'%s' called too late: %s +%d",                      \
                          __FUNCTION__, __FILE__, __LINE__);                   \
      NECKO_MAYBE_ABORT(msg);                                                  \
      if (mIsPending)                                                          \
        return NS_ERROR_IN_PROGRESS;                                           \
      MOZ_ASSERT(mWasOpened);                                                  \
      return NS_ERROR_ALREADY_OPENED;                                          \
    }                                                                          \
  } while (0)

namespace mozilla {
namespace net {

inline bool 
IsNeckoChild() 
{
  static bool didCheck = false;
  static bool amChild = false;

  if (!didCheck) {
    didCheck = true;
    amChild = (XRE_GetProcessType() == GeckoProcessType_Content);
  }
  return amChild;
}

namespace NeckoCommonInternal {
  extern bool gSecurityDisabled;
  extern bool gRegisteredBool;
} // namespace NeckoCommonInternal

// This should always return true unless xpcshell tests are being used
inline bool
UsingNeckoIPCSecurity()
{
  return !NeckoCommonInternal::gSecurityDisabled;
}

inline bool
MissingRequiredTabChild(mozilla::dom::TabChild* tabChild,
                        const char* context)
{
  if (UsingNeckoIPCSecurity()) {
    if (!tabChild) {
      printf_stderr("WARNING: child tried to open %s IPDL channel w/o "
                    "security info\n", context);
      return true;
    }
  }
  return false;
}


} // namespace net
} // namespace mozilla

#endif // mozilla_net_NeckoCommon_h