Message decoding functions should take a MessageDecoder reference
[WebKit-https.git] / Source / WebKit2 / Shared / SandboxExtension.h
1 /*
2  * Copyright (C) 2010 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef SandboxExtension_h
27 #define SandboxExtension_h
28
29 #include <wtf/Forward.h>
30 #include <wtf/Noncopyable.h>
31 #include <wtf/PassRefPtr.h>
32 #include <wtf/RefCounted.h>
33 #include <wtf/text/WTFString.h>
34
35 #if ENABLE(WEB_PROCESS_SANDBOX)
36 typedef struct __WKSandboxExtension* WKSandboxExtensionRef;
37 #endif
38
39 namespace CoreIPC {
40     class ArgumentEncoder;
41     class ArgumentDecoder;
42 }
43
44 namespace WebKit {
45
46 class SandboxExtension : public RefCounted<SandboxExtension> {
47 public:
48     enum Type {
49         ReadOnly,
50         ReadWrite
51     };
52
53     class Handle {
54         WTF_MAKE_NONCOPYABLE(Handle);
55     
56     public:
57         Handle();
58         ~Handle();
59
60         void encode(CoreIPC::ArgumentEncoder&) const;
61         static bool decode(CoreIPC::ArgumentDecoder&, Handle&);
62
63     private:
64         friend class SandboxExtension;
65 #if ENABLE(WEB_PROCESS_SANDBOX)
66         mutable WKSandboxExtensionRef m_sandboxExtension;
67 #endif
68     };
69
70     class HandleArray {
71         WTF_MAKE_NONCOPYABLE(HandleArray);
72         
73     public:
74         HandleArray();
75         ~HandleArray();
76         void allocate(size_t);
77         Handle& operator[](size_t i);
78         const Handle& operator[](size_t i) const;
79         size_t size() const;
80         void encode(CoreIPC::ArgumentEncoder&) const;
81         static bool decode(CoreIPC::ArgumentDecoder&, HandleArray&);
82        
83     private:
84 #if ENABLE(WEB_PROCESS_SANDBOX)
85         Handle* m_data;
86         size_t m_size;
87 #else
88         Handle m_emptyHandle;
89 #endif
90     };
91     
92     static PassRefPtr<SandboxExtension> create(const Handle&);
93     static void createHandle(const String& path, Type type, Handle&);
94     static void createHandleForReadWriteDirectory(const String& path, Handle&); // Will attempt to create the directory.
95     static String createHandleForTemporaryFile(const String& prefix, Type type, Handle&);
96     ~SandboxExtension();
97
98     bool invalidate();
99     bool consume();
100     bool consumePermanently();
101
102     static bool consumePermanently(const Handle&);
103
104 private:
105     explicit SandboxExtension(const Handle&);
106                      
107 #if ENABLE(WEB_PROCESS_SANDBOX)
108     mutable WKSandboxExtensionRef m_sandboxExtension;
109 #endif
110 };
111
112
113 #if !ENABLE(WEB_PROCESS_SANDBOX)
114 inline SandboxExtension::Handle::Handle() { }
115 inline SandboxExtension::Handle::~Handle() { }
116 inline void SandboxExtension::Handle::encode(CoreIPC::ArgumentEncoder&) const { }
117 inline bool SandboxExtension::Handle::decode(CoreIPC::ArgumentDecoder&, Handle&) { return true; }
118 inline SandboxExtension::HandleArray::HandleArray() { }
119 inline SandboxExtension::HandleArray::~HandleArray() { }
120 inline void SandboxExtension::HandleArray::allocate(size_t) { }
121 inline size_t SandboxExtension::HandleArray::size() const { return 0; }    
122 inline const SandboxExtension::Handle& SandboxExtension::HandleArray::operator[](size_t) const { return m_emptyHandle; }
123 inline SandboxExtension::Handle& SandboxExtension::HandleArray::operator[](size_t) { return m_emptyHandle; }
124 inline void SandboxExtension::HandleArray::encode(CoreIPC::ArgumentEncoder&) const { }
125 inline bool SandboxExtension::HandleArray::decode(CoreIPC::ArgumentDecoder&, HandleArray&) { return true; }
126 inline PassRefPtr<SandboxExtension> SandboxExtension::create(const Handle&) { return 0; }
127 inline void SandboxExtension::createHandle(const String&, Type, Handle&) { }
128 inline void SandboxExtension::createHandleForReadWriteDirectory(const String&, Handle&) { }
129 inline String SandboxExtension::createHandleForTemporaryFile(const String& /*prefix*/, Type, Handle&) {return String();}
130 inline SandboxExtension::~SandboxExtension() { }
131 inline bool SandboxExtension::invalidate() { return true; }
132 inline bool SandboxExtension::consume() { return true; }
133 inline bool SandboxExtension::consumePermanently() { return true; }
134 inline bool SandboxExtension::consumePermanently(const Handle&) { return true; }
135 #endif
136
137 } // namespace WebKit
138
139
140 #endif // SandboxExtension_h