forked from chromium/chromium
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathvar_array_buffer.h
More file actions
106 lines (88 loc) · 3.81 KB
/
var_array_buffer.h
File metadata and controls
106 lines (88 loc) · 3.81 KB
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
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef PPAPI_CPP_VAR_ARRAY_BUFFER_H_
#define PPAPI_CPP_VAR_ARRAY_BUFFER_H_
#include <stdint.h>
#include "ppapi/cpp/var.h"
/// @file
/// This file defines the API for interacting with a JavaScript ArrayBuffer.
namespace pp {
/// <code>VarArrayBuffer</code> provides a way to interact with JavaScript
/// ArrayBuffers, which represent a contiguous sequence of bytes. Note that
/// these vars are not part of the embedding page's DOM, and can only be
/// shared with JavaScript using the <code>PostMessage</code> and
/// <code>HandleMessage</code> functions of <code>Instance</code>.
class VarArrayBuffer : public Var {
public:
/// The default constructor constructs a <code>VarArrayBuffer</code> which is
/// 0 byte long.
VarArrayBuffer();
/// Construct a <code>VarArrayBuffer</code> given a var for which
/// is_array_buffer() is true. This will refer to the same
/// <code>ArrayBuffer</code> as var, but allows you to access methods
/// specific to <code>VarArrayBuffer</code>.
///
/// @param[in] var An <code>ArrayBuffer</code> var.
explicit VarArrayBuffer(const Var& var);
/// Construct a new <code>VarArrayBuffer</code> which is
/// <code>size_in_bytes</code> bytes long and initialized to zero.
///
/// @param[in] size_in_bytes The size of the constructed
/// <code>ArrayBuffer</code> in bytes.
explicit VarArrayBuffer(uint32_t size_in_bytes);
/// Copy constructor.
VarArrayBuffer(const VarArrayBuffer& buffer) : Var(buffer) {}
virtual ~VarArrayBuffer() {}
/// This function assigns one <code>VarArrayBuffer</code> to another
/// <code>VarArrayBuffer</code>.
///
/// @param[in] other The <code>VarArrayBuffer</code> to be assigned.
///
/// @return The resulting <code>VarArrayBuffer</code>.
VarArrayBuffer& operator=(const VarArrayBuffer& other);
/// This function assigns one <code>VarArrayBuffer</code> to another
/// <code>VarArrayBuffer</code>. A Var's assignment operator is overloaded
/// here so that we can check for assigning a non-ArrayBuffer var to a
/// <code>VarArrayBuffer</code>.
///
/// @param[in] other The <code>VarArrayBuffer</code> to be assigned.
///
/// @return The resulting <code>VarArrayBuffer</code>
5955
(as a Var&).
virtual Var& operator=(const Var& other);
/// ByteLength() retrieves the length of the <code>VarArrayBuffer</code> in
/// bytes.
///
/// @return The length of the <code>VarArrayBuffer</code> in bytes.
uint32_t ByteLength() const;
/// Map() maps the <code>ArrayBuffer</code> in to the module's address space
/// and returns a pointer to the beginning of the internal buffer for
/// this <code>ArrayBuffer</code>. ArrayBuffers are copied when transmitted,
/// so changes to the underlying memory are not automatically available to
/// the embedding page.
///
/// Note that calling Map() can be a relatively expensive operation. Use care
/// when calling it in performance-critical code. For example, you should call
/// it only once when looping over an <code>ArrayBuffer</code>.
///
/// <strong>Example:</strong>
///
/// @code
/// char* data = static_cast<char*>(array_buffer_var.Map());
/// uint32_t byte_length = array_buffer_var.ByteLength();
/// for (uint32_t i = 0; i < byte_length; ++i)
/// data[i] = 'A';
/// @endcode
///
/// @return A pointer to the internal buffer for this
/// <code>ArrayBuffer</code>.
void* Map();
/// Unmap() unmaps this <code>ArrayBuffer</code> var from the module address
/// space. Use this if you want to save memory but might want to call Map()
/// to map the buffer again later.
void Unmap();
private:
void ConstructWithSize(uint32_t size_in_bytes);
};
} // namespace pp
#endif // PPAPI_CPP_VAR_ARRAY_BUFFER_H_