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
|
// Copyright (c) 2011 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 WEBKIT_TOOLS_TEST_SHELL_SIMPLE_APPCACHE_SYSTEM_H_
#define WEBKIT_TOOLS_TEST_SHELL_SIMPLE_APPCACHE_SYSTEM_H_
#include "base/file_path.h"
#include "base/message_loop.h"
#include "base/threading/thread.h"
#include "webkit/appcache/appcache_backend_impl.h"
#include "webkit/appcache/appcache_frontend_impl.h"
#include "webkit/appcache/appcache_service.h"
#include "webkit/glue/resource_type.h"
namespace WebKit {
class WebApplicationCacheHost;
class WebApplicationCacheHostClient;
}
class SimpleBackendProxy;
class SimpleFrontendProxy;
namespace net {
class URLRequest;
class URLRequestContext;
} // namespace net
// A class that composes the constituent parts of an appcache system
// together for use in a single process with two relavant threads,
// a UI thread on which webkit runs and an IO thread on which URLRequests
// are handled. This class conspires with SimpleResourceLoaderBridge to
// retrieve resources from the appcache.
class SimpleAppCacheSystem {
public:
// Should be instanced somewhere in main(). If not instanced, the public
// static methods are all safe no-ops.
SimpleAppCacheSystem();
virtual ~SimpleAppCacheSystem();
// One-time main UI thread initialization.
static void InitializeOnUIThread(const FilePath& cache_directory) {
if (instance_)
instance_->InitOnUIThread(cache_directory);
}
// Called by SimpleResourceLoaderBridge's IOThread class.
// Per IO thread initialization. Only one IO thread can exist
// at a time, but after IO thread termination a new one can be
// started on which this method should be called. The instance
// is assumed to outlive the IO thread.
static void InitializeOnIOThread(net::URLRequestContext* request_context) {
if (instance_)
instance_->InitOnIOThread(request_context);
}
static void CleanupOnIOThread() {
if (instance_)
instance_->CleanupIOThread();
}
// Called by TestShellWebKitInit to manufacture a 'host' for webcore.
static WebKit::WebApplicationCacheHost* CreateApplicationCacheHost(
WebKit::WebApplicationCacheHostClient* client) {
return instance_ ? instance_->CreateCacheHostForWebKit(client) : NULL;
}
// Called by SimpleResourceLoaderBridge to hook into resource loads.
static void SetExtraRequestInfo(net::URLRequest* request,
int host_id,
ResourceType::Type resource_type) {
if (instance_)
instance_->SetExtraRequestBits(request, host_id, resource_type);
}
// Called by SimpleResourceLoaderBridge extract extra response bits.
static void GetExtraResponseInfo(net::URLRequest* request,
int64* cache_id,
GURL* manifest_url) {
if (instance_)
instance_->GetExtraResponseBits(request, cache_id, manifest_url);
}
private:
friend class SimpleBackendProxy;
friend class SimpleFrontendProxy;
// Instance methods called by our static public methods
void InitOnUIThread(const FilePath& cache_directory);
void InitOnIOThread(net::URLRequestContext* request_context);
void CleanupIOThread();
WebKit::WebApplicationCacheHost* CreateCacheHostForWebKit(
WebKit::WebApplicationCacheHostClient* client);
void SetExtraRequestBits(net::URLRequest* request,
int host_id,
ResourceType::Type resource_type);
void GetExtraResponseBits(net::URLRequest* request,
int64* cache_id,
GURL* manifest_url);
// Helpers
MessageLoop* io_message_loop() { return io_message_loop_; }
MessageLoop* ui_message_loop() { return ui_message_loop_; }
bool is_io_thread() { return MessageLoop::current() == io_message_loop_; }
bool is_ui_thread() { return MessageLoop::current() == ui_message_loop_; }
bool is_initialized() {
return io_message_loop_ && is_initailized_on_ui_thread();
}
bool is_initailized_on_ui_thread() {
return ui_message_loop_ ? true : false;
}
FilePath cache_directory_;
MessageLoop* io_message_loop_;
MessageLoop* ui_message_loop_;
scoped_refptr<SimpleBackendProxy> backend_proxy_;
scoped_refptr<SimpleFrontendProxy> frontend_proxy_;
appcache::AppCacheFrontendImpl frontend_impl_;
// Created and used only on the IO thread, these do
// not survive IO thread termination. If a new IO thread
// is started new instances will be created.
appcache::AppCacheBackendImpl* backend_impl_;
appcache::AppCacheService* service_;
// We start a thread for use as the DB thread.
base::Thread db_thread_;
// A low-tech singleton.
static SimpleAppCacheSystem* instance_;
};
#endif // WEBKIT_TOOLS_TEST_SHELL_SIMPLE_APPCACHE_SYSTEM_H_
|
