OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/command_line.h" | 5 #include "base/command_line.h" |
6 #include "base/logging.h" | 6 #include "base/logging.h" |
7 #include "base/macros.h" | 7 #include "base/macros.h" |
8 #include "base/message_loop/message_loop.h" | 8 #include "base/message_loop/message_loop.h" |
9 #include "base/strings/utf_string_conversions.h" | 9 #include "base/strings/utf_string_conversions.h" |
10 #include "base/threading/thread.h" | 10 #include "base/threading/thread.h" |
(...skipping 12 matching lines...) Expand all Loading... |
23 #include "mojo/services/network/public/interfaces/network_service.mojom.h" | 23 #include "mojo/services/network/public/interfaces/network_service.mojom.h" |
24 #include "third_party/WebKit/public/web/WebKit.h" | 24 #include "third_party/WebKit/public/web/WebKit.h" |
25 | 25 |
26 #if !defined(COMPONENT_BUILD) | 26 #if !defined(COMPONENT_BUILD) |
27 #include "base/i18n/icu_util.h" | 27 #include "base/i18n/icu_util.h" |
28 #include "base/path_service.h" | 28 #include "base/path_service.h" |
29 #include "ui/base/resource/resource_bundle.h" | 29 #include "ui/base/resource/resource_bundle.h" |
30 #include "ui/base/ui_base_paths.h" | 30 #include "ui/base/ui_base_paths.h" |
31 #endif | 31 #endif |
32 | 32 |
33 namespace mojo { | 33 using mojo::ApplicationConnection; |
| 34 using mojo::Array; |
| 35 using mojo::ContentHandler; |
| 36 using mojo::ServiceProviderPtr; |
| 37 using mojo::ShellPtr; |
| 38 using mojo::String; |
| 39 using mojo::URLLoaderPtr; |
| 40 using mojo::URLResponsePtr; |
| 41 |
| 42 namespace html_viewer { |
34 | 43 |
35 // Switches for html_viewer to be used with "--args-for". For example: | 44 // Switches for html_viewer to be used with "--args-for". For example: |
36 // --args-for='mojo:html_viewer --enable-mojo-media-renderer' | 45 // --args-for='mojo:html_viewer --enable-mojo-media-renderer' |
37 | 46 |
38 // Enable MediaRenderer in media pipeline instead of using the internal | 47 // Enable MediaRenderer in media pipeline instead of using the internal |
39 // media::Renderer implementation. | 48 // media::Renderer implementation. |
40 const char kEnableMojoMediaRenderer[] = "enable-mojo-media-renderer"; | 49 const char kEnableMojoMediaRenderer[] = "enable-mojo-media-renderer"; |
41 | 50 |
42 class HTMLViewer; | 51 class HTMLViewer; |
43 | 52 |
44 class HTMLViewerApplication : public Application { | 53 class HTMLViewerApplication : public mojo::Application { |
45 public: | 54 public: |
46 HTMLViewerApplication(ShellPtr shell, | 55 HTMLViewerApplication(ShellPtr shell, |
47 URLResponsePtr response, | 56 URLResponsePtr response, |
48 scoped_refptr<base::MessageLoopProxy> compositor_thread, | 57 scoped_refptr<base::MessageLoopProxy> compositor_thread, |
49 WebMediaPlayerFactory* web_media_player_factory) | 58 WebMediaPlayerFactory* web_media_player_factory) |
50 : url_(response->url), | 59 : url_(response->url), |
51 shell_(shell.Pass()), | 60 shell_(shell.Pass()), |
52 initial_response_(response.Pass()), | 61 initial_response_(response.Pass()), |
53 compositor_thread_(compositor_thread), | 62 compositor_thread_(compositor_thread), |
54 web_media_player_factory_(web_media_player_factory) { | 63 web_media_player_factory_(web_media_player_factory) { |
55 shell_.set_client(this); | 64 shell_.set_client(this); |
56 ServiceProviderPtr service_provider; | 65 ServiceProviderPtr service_provider; |
57 shell_->ConnectToApplication("mojo:network_service", | 66 shell_->ConnectToApplication("mojo:network_service", |
58 GetProxy(&service_provider)); | 67 GetProxy(&service_provider)); |
59 ConnectToService(service_provider.get(), &network_service_); | 68 ConnectToService(service_provider.get(), &network_service_); |
60 } | 69 } |
61 | 70 |
62 void Initialize(Array<String> args) override {} | 71 void Initialize(Array<String> args) override {} |
63 | 72 |
64 void AcceptConnection(const String& requestor_url, | 73 void AcceptConnection(const String& requestor_url, |
65 ServiceProviderPtr provider) override { | 74 ServiceProviderPtr provider) override { |
66 if (initial_response_) { | 75 if (initial_response_) { |
67 OnResponseReceived(URLLoaderPtr(), provider.Pass(), | 76 OnResponseReceived(URLLoaderPtr(), provider.Pass(), |
68 initial_response_.Pass()); | 77 initial_response_.Pass()); |
69 } else { | 78 } else { |
70 URLLoaderPtr loader; | 79 URLLoaderPtr loader; |
71 network_service_->CreateURLLoader(GetProxy(&loader)); | 80 network_service_->CreateURLLoader(GetProxy(&loader)); |
72 URLRequestPtr request(URLRequest::New()); | 81 mojo::URLRequestPtr request(mojo::URLRequest::New()); |
73 request->url = url_; | 82 request->url = url_; |
74 request->auto_follow_redirects = true; | 83 request->auto_follow_redirects = true; |
75 | 84 |
76 // |loader| will be pass to the OnResponseReceived method through a | 85 // |loader| will be pass to the OnResponseReceived method through a |
77 // callback. Because order of evaluation is undefined, a reference to the | 86 // callback. Because order of evaluation is undefined, a reference to the |
78 // raw pointer is needed. | 87 // raw pointer is needed. |
79 URLLoader* raw_loader = loader.get(); | 88 mojo::URLLoader* raw_loader = loader.get(); |
80 raw_loader->Start( | 89 raw_loader->Start( |
81 request.Pass(), | 90 request.Pass(), |
82 base::Bind(&HTMLViewerApplication::OnResponseReceived, | 91 base::Bind(&HTMLViewerApplication::OnResponseReceived, |
83 base::Unretained(this), base::Passed(&loader), | 92 base::Unretained(this), base::Passed(&loader), |
84 base::Passed(&provider))); | 93 base::Passed(&provider))); |
85 } | 94 } |
86 } | 95 } |
87 | 96 |
88 private: | 97 private: |
89 void OnResponseReceived(URLLoaderPtr loader, | 98 void OnResponseReceived(URLLoaderPtr loader, |
90 ServiceProviderPtr provider, | 99 ServiceProviderPtr provider, |
91 URLResponsePtr response) { | 100 URLResponsePtr response) { |
92 new HTMLDocument(provider.Pass(), response.Pass(), shell_.get(), | 101 new HTMLDocument(provider.Pass(), response.Pass(), shell_.get(), |
93 compositor_thread_, web_media_player_factory_); | 102 compositor_thread_, web_media_player_factory_); |
94 } | 103 } |
95 | 104 |
96 String url_; | 105 String url_; |
97 ShellPtr shell_; | 106 ShellPtr shell_; |
98 NetworkServicePtr network_service_; | 107 mojo::NetworkServicePtr network_service_; |
99 URLResponsePtr initial_response_; | 108 URLResponsePtr initial_response_; |
100 scoped_refptr<base::MessageLoopProxy> compositor_thread_; | 109 scoped_refptr<base::MessageLoopProxy> compositor_thread_; |
101 WebMediaPlayerFactory* web_media_player_factory_; | 110 WebMediaPlayerFactory* web_media_player_factory_; |
102 }; | 111 }; |
103 | 112 |
104 class ContentHandlerImpl : public InterfaceImpl<ContentHandler> { | 113 class ContentHandlerImpl : public mojo::InterfaceImpl<ContentHandler> { |
105 public: | 114 public: |
106 ContentHandlerImpl(scoped_refptr<base::MessageLoopProxy> compositor_thread, | 115 ContentHandlerImpl(scoped_refptr<base::MessageLoopProxy> compositor_thread, |
107 WebMediaPlayerFactory* web_media_player_factory) | 116 WebMediaPlayerFactory* web_media_player_factory) |
108 : compositor_thread_(compositor_thread), | 117 : compositor_thread_(compositor_thread), |
109 web_media_player_factory_(web_media_player_factory) {} | 118 web_media_player_factory_(web_media_player_factory) {} |
110 ~ContentHandlerImpl() override {} | 119 ~ContentHandlerImpl() override {} |
111 | 120 |
112 private: | 121 private: |
113 // Overridden from ContentHandler: | 122 // Overridden from ContentHandler: |
114 void StartApplication(ShellPtr shell, URLResponsePtr response) override { | 123 void StartApplication(ShellPtr shell, URLResponsePtr response) override { |
115 new HTMLViewerApplication(shell.Pass(), response.Pass(), compositor_thread_, | 124 new HTMLViewerApplication(shell.Pass(), response.Pass(), compositor_thread_, |
116 web_media_player_factory_); | 125 web_media_player_factory_); |
117 } | 126 } |
118 | 127 |
119 scoped_refptr<base::MessageLoopProxy> compositor_thread_; | 128 scoped_refptr<base::MessageLoopProxy> compositor_thread_; |
120 WebMediaPlayerFactory* web_media_player_factory_; | 129 WebMediaPlayerFactory* web_media_player_factory_; |
121 | 130 |
122 DISALLOW_COPY_AND_ASSIGN(ContentHandlerImpl); | 131 DISALLOW_COPY_AND_ASSIGN(ContentHandlerImpl); |
123 }; | 132 }; |
124 | 133 |
125 class HTMLViewer : public ApplicationDelegate, | 134 class HTMLViewer : public mojo::ApplicationDelegate, |
126 public InterfaceFactory<ContentHandler> { | 135 public mojo::InterfaceFactory<ContentHandler> { |
127 public: | 136 public: |
128 HTMLViewer() : compositor_thread_("compositor thread") {} | 137 HTMLViewer() : compositor_thread_("compositor thread") {} |
129 | 138 |
130 ~HTMLViewer() override { blink::shutdown(); } | 139 ~HTMLViewer() override { blink::shutdown(); } |
131 | 140 |
132 private: | 141 private: |
133 // Overridden from ApplicationDelegate: | 142 // Overridden from ApplicationDelegate: |
134 void Initialize(ApplicationImpl* app) override { | 143 void Initialize(mojo::ApplicationImpl* app) override { |
135 blink_platform_.reset(new MojoBlinkPlatformImpl(app)); | 144 blink_platform_.reset(new MojoBlinkPlatformImpl(app)); |
136 #if defined(V8_USE_EXTERNAL_STARTUP_DATA) | 145 #if defined(V8_USE_EXTERNAL_STARTUP_DATA) |
137 gin::IsolateHolder::LoadV8Snapshot(); | 146 gin::IsolateHolder::LoadV8Snapshot(); |
138 #endif | 147 #endif |
139 blink::initialize(blink_platform_.get()); | 148 blink::initialize(blink_platform_.get()); |
140 #if !defined(COMPONENT_BUILD) | 149 #if !defined(COMPONENT_BUILD) |
141 base::i18n::InitializeICU(); | 150 base::i18n::InitializeICU(); |
142 | 151 |
143 ui::RegisterPathProvider(); | 152 ui::RegisterPathProvider(); |
144 | 153 |
(...skipping 25 matching lines...) Expand all Loading... |
170 compositor_thread_.message_loop_proxy(), enable_mojo_media_renderer)); | 179 compositor_thread_.message_loop_proxy(), enable_mojo_media_renderer)); |
171 } | 180 } |
172 | 181 |
173 bool ConfigureIncomingConnection(ApplicationConnection* connection) override { | 182 bool ConfigureIncomingConnection(ApplicationConnection* connection) override { |
174 connection->AddService(this); | 183 connection->AddService(this); |
175 return true; | 184 return true; |
176 } | 185 } |
177 | 186 |
178 // Overridden from InterfaceFactory<ContentHandler> | 187 // Overridden from InterfaceFactory<ContentHandler> |
179 void Create(ApplicationConnection* connection, | 188 void Create(ApplicationConnection* connection, |
180 InterfaceRequest<ContentHandler> request) override { | 189 mojo::InterfaceRequest<ContentHandler> request) override { |
181 BindToRequest( | 190 BindToRequest( |
182 new ContentHandlerImpl(compositor_thread_.message_loop_proxy(), | 191 new ContentHandlerImpl(compositor_thread_.message_loop_proxy(), |
183 web_media_player_factory_.get()), | 192 web_media_player_factory_.get()), |
184 &request); | 193 &request); |
185 } | 194 } |
186 | 195 |
187 scoped_ptr<MojoBlinkPlatformImpl> blink_platform_; | 196 scoped_ptr<MojoBlinkPlatformImpl> blink_platform_; |
188 base::Thread compositor_thread_; | 197 base::Thread compositor_thread_; |
189 scoped_ptr<WebMediaPlayerFactory> web_media_player_factory_; | 198 scoped_ptr<WebMediaPlayerFactory> web_media_player_factory_; |
190 | 199 |
191 DISALLOW_COPY_AND_ASSIGN(HTMLViewer); | 200 DISALLOW_COPY_AND_ASSIGN(HTMLViewer); |
192 }; | 201 }; |
193 | 202 |
194 } // namespace mojo | |
195 | |
196 MojoResult MojoMain(MojoHandle shell_handle) { | 203 MojoResult MojoMain(MojoHandle shell_handle) { |
197 mojo::ApplicationRunnerChromium runner(new mojo::HTMLViewer); | 204 mojo::ApplicationRunnerChromium runner(new HTMLViewer); |
198 return runner.Run(shell_handle); | 205 return runner.Run(shell_handle); |
199 } | 206 } |
| 207 |
| 208 } // namespace html_viewer |
OLD | NEW |