Build target for Android WebView.

chrome/renderer/chrome_content_renderer_client.cc

 // 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 "chrome/renderer/chrome_content_renderer_client.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 335 matching lines @@
     content::RenderView* render_view,
     WebKit::WebFrame* frame,
     WebKit::WebMediaPlayerClient* client,
     base::WeakPtr<webkit_media::WebMediaPlayerDelegate> delegate,
     media::FilterCollection* collection,
     WebKit::WebAudioSourceProvider* audio_source_provider,
     media::AudioRendererSink* audio_renderer_sink,
     media::MessageLoopFactory* message_loop_factory,
     webkit_media::MediaStreamClient* media_stream_client,
     media::MediaLog* media_log) {
+#if defined(OS_ANDROID)

[Jói, 2012/08/07 13:49:47]

It seems like you can avoid this #if and the one below by writing a subclass of
ChromeContentRendererClient and instantiating that instead in
WebViewMainDelegate.

[Torne, 2012/08/07 13:58:09]

These things need to be disabled for the regular Chrome for Android build as
well, which doesn't support prerendering or extensions either. It's not specific
to WebView; these things simply aren't implemented for Android (we don't build a
PrerenderWebMediaPlayer).

For WebView specifically, writing our own version of the class is exactly the
intention. However, this is likely to require copy+pasting the implementations
of many of the other functions defined here, since there's no alternative
implementation to use. Future CLs will implement our own versions of these
classes as we work out exactly which functionality is required.

[Jói, 2012/08/07 14:17:31]

Thanks for the explanation Torne, that makes sense.

In this case, one approach would be to pull everything used by both Clank and
desktop-Chrome into a CommonContentRendererClient that implements these two
methods by returning NULL, with a subclass ChromeContentRendererClient that
implements them "for real".

Whether this should be done or #if statements should be used kind of depends on
what end state we are aiming for.  You talked about having your own
implementation of ContentRendererClient, but you also said you might copy+paste
a lot from the ChromeContentRendererClient implementation.  If it's more like
the latter, then possibly the common base class approach (i.e. a
CommonContentRendererClient) is viable.  If it's more like the former, then I
guess the current set of #if statements is fine for now, but obviously once you
have the separate implementation then if it's doing the "same thing" more or
less, then the code ideally shouldn't be copied and pasted but rather reused -
but we can figure out how to do that at the right time.

+  // Chromium for Android doesn't support prerender yet.
+  return NULL;
+#else
   if (!prerender::PrerenderHelper::IsPrerendering(render_view))
     return NULL;
 
   return new prerender::PrerenderWebMediaPlayer(render_view, frame, client,
       delegate, collection, audio_source_provider, audio_renderer_sink,
       message_loop_factory, media_stream_client, media_log);
+#endif
 }
 
 WebPlugin* ChromeContentRendererClient::CreatePlugin(
     content::RenderView* render_view,
     WebFrame* frame,
     const WebPluginParams& original_params,
     const ChromeViewHostMsg_GetPluginInfo_Status& status,
     const webkit::WebPluginInfo& plugin,
     const std::string& actual_mime_type) {
   ChromeViewHostMsg_GetPluginInfo_Status::Value status_value = status.value;
@@ skipping 431 matching lines @@
 bool ChromeContentRendererClient::ShouldPumpEventsDuringCookieMessage() {
   // We no longer pump messages, even under Chrome Frame. We rely on cookie
   // read requests handled by CF not putting up UI or causing other actions
   // that would require us to pump messages. This fixes http://crbug.com/110090.
   return false;
 }
 
 void ChromeContentRendererClient::DidCreateScriptContext(
     WebFrame* frame, v8::Handle<v8::Context> context, int extension_group,
     int world_id) {
+#if !defined(OS_ANDROID)
+  // Chromium for Android doesn't have extensions.
   extension_dispatcher_->DidCreateScriptContext(
       frame, context, extension_group, world_id);
+#endif
 }
 
 void ChromeContentRendererClient::WillReleaseScriptContext(
     WebFrame* frame, v8::Handle<v8::Context> context, int world_id) {
   extension_dispatcher_->WillReleaseScriptContext(frame, context, world_id);
 }
 
 unsigned long long ChromeContentRendererClient::VisitedLinkHash(
     const char* canonical_url, size_t length) {
   return visited_link_slave_->ComputeURLFingerprint(canonical_url, length);
@@ skipping 122 matching lines @@
 bool ChromeContentRendererClient::IsOtherExtensionWithWebRequestInstalled() {
   return extension_dispatcher_->IsOtherExtensionWithWebRequestInstalled();
 }
 
 void ChromeContentRendererClient::RegisterPPAPIInterfaceFactories(
     webkit::ppapi::PpapiInterfaceFactoryManager* factory_manager) {
   factory_manager->RegisterFactory(ChromePPAPIInterfaceFactory);
 }
 
 }  // namespace chrome