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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_CALLBACKS_H_
#define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_CALLBACKS_H_
#include <stdint.h>
#include <memory>
#include <string>
#include <vector>
#include "base/logging.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/strings/string16.h"
#include "content/browser/indexed_db/indexed_db_database_error.h"
#include "content/browser/indexed_db/indexed_db_dispatcher_host.h"
#include "content/common/indexed_db/indexed_db_key.h"
#include "content/common/indexed_db/indexed_db_key_path.h"
#include "url/origin.h"
namespace content {
class IndexedDBBlobInfo;
class IndexedDBConnection;
class IndexedDBCursor;
class IndexedDBDatabase;
class IndexedDBDatabaseCallbacks;
struct IndexedDBDatabaseMetadata;
struct IndexedDBReturnValue;
struct IndexedDBValue;
class CONTENT_EXPORT IndexedDBCallbacks
: public base::RefCounted<IndexedDBCallbacks> {
public:
// Simple payload responses
IndexedDBCallbacks(IndexedDBDispatcherHost* dispatcher_host,
int32_t ipc_thread_id,
int32_t ipc_callbacks_id);
// IndexedDBCursor responses
IndexedDBCallbacks(IndexedDBDispatcherHost* dispatcher_host,
int32_t ipc_thread_id,
int32_t ipc_callbacks_id,
int32_t ipc_cursor_id);
// IndexedDBDatabase responses
IndexedDBCallbacks(IndexedDBDispatcherHost* dispatcher_host,
int32_t ipc_thread_id,
int32_t ipc_callbacks_id,
int32_t ipc_database_callbacks_id,
int64_t host_transaction_id,
const url::Origin& origin);
virtual void OnError(const IndexedDBDatabaseError& error);
// IndexedDBFactory::GetDatabaseNames
virtual void OnSuccess(const std::vector<base::string16>& string);
// IndexedDBFactory::Open / DeleteDatabase
virtual void OnBlocked(int64_t existing_version);
// IndexedDBFactory::Open
virtual void OnDataLoss(blink::WebIDBDataLoss data_loss,
std::string data_loss_message);
virtual void OnUpgradeNeeded(
int64_t old_version,
std::unique_ptr<IndexedDBConnection> connection,
const content::IndexedDBDatabaseMetadata& metadata);
virtual void OnSuccess(std::unique_ptr<IndexedDBConnection> connection,
const content::IndexedDBDatabaseMetadata& metadata);
// IndexedDBDatabase::OpenCursor
virtual void OnSuccess(scoped_refptr<IndexedDBCursor> cursor,
const IndexedDBKey& key,
const IndexedDBKey& primary_key,
IndexedDBValue* value);
// IndexedDBCursor::Continue / Advance
virtual void OnSuccess(const IndexedDBKey& key,
const IndexedDBKey& primary_key,
IndexedDBValue* value);
// IndexedDBCursor::PrefetchContinue
virtual void OnSuccessWithPrefetch(
const std::vector<IndexedDBKey>& keys,
const std::vector<IndexedDBKey>& primary_keys,
std::vector<IndexedDBValue>* values);
// IndexedDBDatabase::Get
// IndexedDBCursor::Advance
virtual void OnSuccess(IndexedDBReturnValue* value);
// IndexedDBDatabase::GetAll
virtual void OnSuccessArray(std::vector<IndexedDBReturnValue>* values,
const IndexedDBKeyPath& key_path);
// IndexedDBDatabase::Put / IndexedDBCursor::Update
virtual void OnSuccess(const IndexedDBKey& key);
// IndexedDBDatabase::Count
// IndexedDBFactory::DeleteDatabase
virtual void OnSuccess(int64_t value);
// IndexedDBDatabase::Delete
// IndexedDBCursor::Continue / Advance (when complete)
virtual void OnSuccess();
blink::WebIDBDataLoss data_loss() const { return data_loss_; }
void SetConnectionOpenStartTime(const base::TimeTicks& start_time);
protected:
virtual ~IndexedDBCallbacks();
private:
void RegisterBlobsAndSend(const std::vector<IndexedDBBlobInfo>& blob_info,
const base::Closure& callback);
friend class base::RefCounted<IndexedDBCallbacks>;
// Originally from IndexedDBCallbacks:
scoped_refptr<IndexedDBDispatcherHost> dispatcher_host_;
int32_t ipc_callbacks_id_;
int32_t ipc_thread_id_;
// IndexedDBCursor callbacks ------------------------
int32_t ipc_cursor_id_;
// IndexedDBDatabase callbacks ------------------------
int64_t host_transaction_id_;
url::Origin origin_;
int32_t ipc_database_id_;
int32_t ipc_database_callbacks_id_;
// Stored in OnDataLoss, merged with OnUpgradeNeeded response.
blink::WebIDBDataLoss data_loss_;
std::string data_loss_message_;
// The "blocked" event should be sent at most once per request.
bool sent_blocked_;
base::TimeTicks connection_open_start_time_;
DISALLOW_COPY_AND_ASSIGN(IndexedDBCallbacks);
};
} // namespace content
#endif // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_CALLBACKS_H_
|
