blob: 99be0505e00ac7e51f8ac319cea5b63534d64473 (
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
131
|
// 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.
// TODO(ajwong): We need to come up with a better description of the
// responsibilities for each thread.
#ifndef REMOTING_CLIENT_PLUGIN_CHROMOTING_INSTANCE_H_
#define REMOTING_CLIENT_PLUGIN_CHROMOTING_INSTANCE_H_
#include <string>
#include "base/gtest_prod_util.h"
#include "base/memory/scoped_ptr.h"
#include "ppapi/c/pp_instance.h"
#include "ppapi/c/pp_rect.h"
#include "ppapi/c/pp_resource.h"
#include "ppapi/cpp/var.h"
#include "ppapi/cpp/private/instance_private.h"
#include "remoting/client/client_context.h"
#include "remoting/client/plugin/chromoting_scriptable_object.h"
#include "remoting/client/plugin/pepper_client_logger.h"
#include "remoting/protocol/connection_to_host.h"
class MessageLoop;
struct PP_InputEvent;
namespace base {
class Thread;
} // namespace base
namespace pp {
class Module;
} // namespace pp
namespace remoting {
namespace protocol {
class ConnectionToHost;
} // namespace protocol
class ChromotingClient;
class ChromotingStats;
class ClientContext;
class InputHandler;
class JingleThread;
class PepperView;
class PepperViewProxy;
class RectangleUpdateDecoder;
struct ClientConfig;
namespace protocol {
class HostConnection;
} // namespace protocol
class ChromotingInstance : public pp::InstancePrivate {
public:
// The mimetype for which this plugin is registered.
static const char *kMimeType;
explicit ChromotingInstance(PP_Instance instance);
virtual ~ChromotingInstance();
virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]);
virtual void Connect(const ClientConfig& config);
virtual bool HandleInputEvent(const PP_InputEvent& event);
virtual void Disconnect();
virtual pp::Var GetInstanceObject();
virtual void ViewChanged(const pp::Rect& position, const pp::Rect& clip);
// pp::Instance interface.
virtual void DidChangeView(const pp::Rect& position, const pp::Rect& clip)
OVERRIDE;
// Convenience wrapper to get the ChromotingScriptableObject.
ChromotingScriptableObject* GetScriptableObject();
// Called by ChromotingScriptableObject to provide username and password.
void SubmitLoginInfo(const std::string& username,
const std::string& password);
// Called by ChromotingScriptableObject to set scale-to-fit.
void SetScaleToFit(bool scale_to_fit);
void Log(int severity, const char* format, ...);
void VLog(int verboselevel, const char* format, ...);
// Return statistics record by ChromotingClient.
// If no connection is currently active then NULL will be returned.
ChromotingStats* GetStats();
private:
FRIEND_TEST_ALL_PREFIXES(ChromotingInstanceTest, TestCaseSetup);
bool initialized_;
ClientContext context_;
scoped_ptr<protocol::ConnectionToHost> host_connection_;
scoped_ptr<PepperView> view_;
// PepperViewProxy is refcounted and used to interface between chromoting
// objects and PepperView and perform thread switching. It wraps around
// |view_| and receives method calls on chromoting threads. These method
// calls are then delegates on the pepper thread. During destruction of
// ChromotingInstance we need to detach PepperViewProxy from PepperView since
// both ChromotingInstance and PepperView are destroyed and there will be
// outstanding tasks on the pepper message loo.
scoped_refptr<PepperViewProxy> view_proxy_;
scoped_refptr<RectangleUpdateDecoder> rectangle_decoder_;
scoped_ptr<InputHandler> input_handler_;
scoped_ptr<ChromotingClient> client_;
// XmppProxy is a refcounted interface used to perform thread-switching and
// detaching between objects whose lifetimes are controlled by pepper, and
// jingle_glue objects. This is used when if we start a sandboxed jingle
// connection.
scoped_refptr<PepperXmppProxy> xmpp_proxy_;
PepperClientLogger logger_;
// JavaScript interface to control this instance.
// This wraps a ChromotingScriptableObject in a pp::Var.
pp::Var instance_object_;
DISALLOW_COPY_AND_ASSIGN(ChromotingInstance);
};
} // namespace remoting
#endif // REMOTING_CLIENT_PLUGIN_CHROMOTING_INSTANCE_H_
|
