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
150
151
152
153
154
155
156
|
// 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.
#include "content/renderer/gpu/compositor_output_surface.h"
#include "base/message_loop_proxy.h"
#include "cc/compositor_frame.h"
#include "cc/output_surface_client.h"
#include "content/common/view_messages.h"
#include "content/renderer/render_thread_impl.h"
#include "ipc/ipc_forwarding_message_filter.h"
#include "ipc/ipc_sync_channel.h"
#include "ipc/ipc_sync_message_filter.h"
#include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsContext3D.h"
#if defined(OS_ANDROID)
// TODO(epenner): Move thread priorities to base. (crbug.com/170549)
#include <sys/resource.h>
#endif
using cc::CompositorFrame;
using cc::SoftwareOutputDevice;
using WebKit::WebGraphicsContext3D;
namespace {
// There are several compositor surfaces in a process, but they share the same
// compositor thread, so we use a simple int here to track prefer-smoothness.
int g_prefer_smoothness_count = 0;
} // namespace
namespace content {
//------------------------------------------------------------------------------
// static
IPC::ForwardingMessageFilter* CompositorOutputSurface::CreateFilter(
base::TaskRunner* target_task_runner)
{
uint32 messages_to_filter[] = {ViewMsg_UpdateVSyncParameters::ID};
return new IPC::ForwardingMessageFilter(
messages_to_filter, arraysize(messages_to_filter),
target_task_runner);
}
CompositorOutputSurface::CompositorOutputSurface(
int32 routing_id,
WebGraphicsContext3D* context3D,
cc::SoftwareOutputDevice* software_device)
: OutputSurface(make_scoped_ptr(context3D),
make_scoped_ptr(software_device)),
output_surface_filter_(
RenderThreadImpl::current()->compositor_output_surface_filter()),
routing_id_(routing_id),
prefers_smoothness_(false),
main_thread_id_(base::PlatformThread::CurrentId()) {
DCHECK(output_surface_filter_);
capabilities_.has_parent_compositor = false;
DetachFromThread();
}
CompositorOutputSurface::~CompositorOutputSurface() {
DCHECK(CalledOnValidThread());
if (!client_)
return;
UpdateSmoothnessTakesPriority(false);
if (output_surface_proxy_)
output_surface_proxy_->ClearOutputSurface();
output_surface_filter_->RemoveRoute(routing_id_);
}
bool CompositorOutputSurface::BindToClient(
cc::OutputSurfaceClient* client) {
DCHECK(CalledOnValidThread());
if (!cc::OutputSurface::BindToClient(client))
return false;
output_surface_proxy_ = new CompositorOutputSurfaceProxy(this);
output_surface_filter_->AddRoute(
routing_id_,
base::Bind(&CompositorOutputSurfaceProxy::OnMessageReceived,
output_surface_proxy_));
return true;
}
void CompositorOutputSurface::SendFrameToParentCompositor(
cc::CompositorFrame* frame) {
DCHECK(CalledOnValidThread());
Send(new ViewHostMsg_SwapCompositorFrame(routing_id_, *frame));
}
void CompositorOutputSurface::OnMessageReceived(const IPC::Message& message) {
DCHECK(CalledOnValidThread());
if (!client_)
return;
IPC_BEGIN_MESSAGE_MAP(CompositorOutputSurface, message)
IPC_MESSAGE_HANDLER(ViewMsg_UpdateVSyncParameters, OnUpdateVSyncParameters);
IPC_END_MESSAGE_MAP()
}
void CompositorOutputSurface::OnUpdateVSyncParameters(
base::TimeTicks timebase, base::TimeDelta interval) {
DCHECK(CalledOnValidThread());
DCHECK(client_);
client_->OnVSyncParametersChanged(timebase, interval);
}
bool CompositorOutputSurface::Send(IPC::Message* message) {
return ChildThread::current()->sync_message_filter()->Send(message);
}
namespace {
#if defined(OS_ANDROID)
// TODO(epenner): Move thread priorities to base. (crbug.com/170549)
void SetThreadsPriorityToIdle(base::PlatformThreadId id) {
int nice_value = 10; // Idle priority.
setpriority(PRIO_PROCESS, id, nice_value);
}
void SetThreadsPriorityToDefault(base::PlatformThreadId id) {
int nice_value = 0; // Default priority.
setpriority(PRIO_PROCESS, id, nice_value);
}
#else
void SetThreadsPriorityToIdle(base::PlatformThreadId id) {}
void SetThreadsPriorityToDefault(base::PlatformThreadId id) {}
#endif
}
void CompositorOutputSurface::UpdateSmoothnessTakesPriority(
bool prefers_smoothness) {
#ifndef NDEBUG
// If we use different compositor threads, we need to
// use an atomic int to track prefer smoothness count.
base::PlatformThreadId g_last_thread = base::PlatformThread::CurrentId();
DCHECK_EQ(g_last_thread, base::PlatformThread::CurrentId());
#endif
if (prefers_smoothness_ == prefers_smoothness)
return;
// If this is the first surface to start preferring smoothness,
// Throttle the main thread's priority.
if (prefers_smoothness_ == false &&
++g_prefer_smoothness_count == 1) {
SetThreadsPriorityToIdle(main_thread_id_);
}
// If this is the last surface to stop preferring smoothness,
// Reset the main thread's priority to the default.
if (prefers_smoothness_ == true &&
--g_prefer_smoothness_count == 0) {
SetThreadsPriorityToDefault(main_thread_id_);
}
prefers_smoothness_ = prefers_smoothness;
}
} // namespace content
|
