Add a gyp flag to allow removing dependency on ppapi.

content/renderer/render_view_impl.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 "content/renderer/render_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/bind.h"
@@ skipping 70 matching lines @@
 #include "content/renderer/load_progress_tracker.h"
 #include "content/renderer/media/media_stream_dependency_factory.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/media_stream_impl.h"
 #include "content/renderer/media/render_audiosourceprovider.h"
 #include "content/renderer/media/render_media_log.h"
 #include "content/renderer/media/renderer_gpu_video_decoder_factories.h"
 #include "content/renderer/media/rtc_peer_connection_handler.h"
 #include "content/renderer/mhtml_generator.h"
 #include "content/renderer/notification_provider.h"
+#include "content/renderer/pepper/pepper_plugin_delegate_impl.h"
 #include "content/renderer/plugin_channel_host.h"
 #include "content/renderer/render_process.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl_params.h"
 #include "content/renderer/render_view_mouse_lock_dispatcher.h"
 #include "content/renderer/render_widget_fullscreen_pepper.h"
 #include "content/renderer/renderer_accessibility.h"
 #include "content/renderer/renderer_accessibility_complete.h"
 #include "content/renderer/renderer_accessibility_focus_only.h"
 #include "content/renderer/renderer_webapplicationcachehost_impl.h"
@@ skipping 89 matching lines @@
 #include "webkit/glue/webkit_constants.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/weburlresponse_extradata_impl.h"
 #include "webkit/gpu/webgraphicscontext3d_in_process_impl.h"
 #include "webkit/media/webmediaplayer_impl.h"
 #include "webkit/media/webmediaplayer_ms.h"
 #include "webkit/plugins/npapi/plugin_list.h"
 #include "webkit/plugins/npapi/webplugin_delegate.h"
 #include "webkit/plugins/npapi/webplugin_delegate_impl.h"
 #include "webkit/plugins/npapi/webplugin_impl.h"
-#include "webkit/plugins/ppapi/ppapi_webplugin_impl.h"
 
 #if defined(OS_ANDROID)
 #include "content/common/android/device_info.h"
 #include "content/renderer/android/address_detector.h"
 #include "content/renderer/android/content_detector.h"
 #include "content/renderer/android/email_detector.h"
 #include "content/renderer/android/phone_number_detector.h"
 #include "content/renderer/media/stream_texture_factory_impl_android.h"
 #include "content/renderer/media/webmediaplayer_proxy_impl_android.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebHitTestResult.h"
@@ skipping 385 matching lines @@
 #endif
       session_storage_namespace_id_(params->session_storage_namespace_id),
       handling_select_range_(false),
 #if defined(OS_WIN)
       focused_plugin_id_(-1),
 #endif
       updating_frame_tree_(false),
       pending_frame_tree_update_(false),
       target_process_id_(0),
       target_routing_id_(0),
-      ALLOW_THIS_IN_INITIALIZER_LIST(pepper_delegate_(this)) {
+#if defined(ENABLE_PPAPI)
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+          pepper_delegate_(new PepperPluginDelegateImpl(this)))
+#else
+      pepper_delegate_(new PluginDelegateHelper())
+#endif
+{
   set_throttle_input_events(params->renderer_prefs.throttle_input_events);
   routing_id_ = params->routing_id;
   surface_id_ = params->surface_id;
   if (params->opener_id != MSG_ROUTING_NONE && params->is_renderer_created)
     opener_id_ = params->opener_id;
 
   // Ensure we start with a valid next_page_id_ from the browser.
   DCHECK_GE(next_page_id_, 0);
 
 #if defined(ENABLE_NOTIFICATIONS)
@@ skipping 3747 matching lines @@
     }
   }
 
   return false;
 }
 
 WebKit::WebPlugin* RenderViewImpl::CreatePlugin(
     WebKit::WebFrame* frame,
     const webkit::WebPluginInfo& info,
     const WebKit::WebPluginParams& params) {
-  bool pepper_plugin_was_registered = false;
-  scoped_refptr<webkit::ppapi::PluginModule> pepper_module(
-      pepper_delegate_.CreatePepperPluginModule(info,
-                                                &pepper_plugin_was_registered));
-  if (pepper_plugin_was_registered) {
-    if (!pepper_module)
-      return NULL;
-    return new webkit::ppapi::WebPluginImpl(
-        pepper_module.get(), params, pepper_delegate_.AsWeakPtr());
-  }
+  WebKit::WebPlugin* pepper_webplugin =
+      pepper_delegate_->CreatePepperWebPlugin(info, params);
+
+  if (pepper_webplugin) return pepper_webplugin;

[Jay Civelli, 2012/11/29 18:57:43]

Return statement should be on its own line in C++.

[nilesh, 2012/11/29 22:54:04]

Done.

 
 #if defined(USE_AURA) && !defined(OS_WIN)
   return NULL;
 #else
   return new webkit::npapi::WebPluginImpl(
       frame, params, info.path, AsWeakPtr());
 #endif
 }
 
 void RenderViewImpl::EvaluateScript(const string16& frame_xpath,
@@ skipping 163 matching lines @@
 
 void RenderViewImpl::SyncSelectionIfRequired() {
   WebFrame* frame = webview()->focusedFrame();
   if (!frame)
     return;
 
   string16 text;
   size_t offset;
   ui::Range range;
 
-  if (pepper_delegate_.IsPluginFocused()) {
-    pepper_delegate_.GetSurroundingText(&text, &range);
+  if (pepper_delegate_->IsPluginFocused()) {
+    pepper_delegate_->GetSurroundingText(&text, &range);
     offset = 0;  // Pepper API does not support offset reporting.
     // TODO(kinaba): cut as needed.
   } else {
     size_t location, length;
     if (!webview()->caretOrSelectionRange(&location, &length))
       return;
 
     range = ui::Range(location, location + length);
 
     if (webview()->textInputType() != WebKit::WebTextInputTypeNone) {
@@ skipping 965 matching lines @@
           ShouldDisplayScrollbars(new_size.width(), new_size.height()));
     }
     UpdateScrollState(webview()->mainFrame());
   }
 
   RenderWidget::OnResize(new_size, resizer_rect, is_fullscreen);
 }
 
 void RenderViewImpl::WillInitiatePaint() {
   // Notify the pepper plugins that we're about to paint.
-  pepper_delegate_.ViewWillInitiatePaint();
+  pepper_delegate_->ViewWillInitiatePaint();
 }
 
 void RenderViewImpl::DidInitiatePaint() {
   // Notify the pepper plugins that we've painted, and are waiting to flush.
-  pepper_delegate_.ViewInitiatedPaint();
+  pepper_delegate_->ViewInitiatedPaint();
 }
 
 void RenderViewImpl::DidFlushPaint() {
   // Notify any pepper plugins that we painted. This will call into the plugin,
   // and we it may ask to close itself as a result. This will, in turn, modify
   // our set, possibly invalidating the iterator. So we iterate on a copy that
   // won't change out from under us.
-  pepper_delegate_.ViewFlushedPaint();
+  pepper_delegate_->ViewFlushedPaint();
 
   // If the RenderWidget is closing down then early-exit, otherwise we'll crash.
   // See crbug.com/112921.
   if (!webview())
     return;
 
   WebFrame* main_frame = webview()->mainFrame();
 
   // If we have a provisional frame we are between the start and commit stages
   // of loading and we don't want to save stats.
@@ skipping 25 matching lines @@
 void RenderViewImpl::OnViewContextSwapBuffersAborted() {
   RenderWidget::OnSwapBuffersAborted();
 }
 
 webkit::ppapi::PluginInstance* RenderViewImpl::GetBitmapForOptimizedPluginPaint(
     const gfx::Rect& paint_bounds,
     TransportDIB** dib,
     gfx::Rect* location,
     gfx::Rect* clip,
     float* scale_factor) {
-  return pepper_delegate_.GetBitmapForOptimizedPluginPaint(
+  return pepper_delegate_->GetBitmapForOptimizedPluginPaint(
       paint_bounds, dib, location, clip, scale_factor);
 }
 
 gfx::Vector2d RenderViewImpl::GetScrollOffset() {
   WebSize scroll_offset = webview()->mainFrame()->scrollOffset();
   return gfx::Vector2d(scroll_offset.width, scroll_offset.height);
 }
 
 void RenderViewImpl::OnClearFocusedNode() {
   if (webview())
@@ skipping 99 matching lines @@
 
 void RenderViewImpl::DidHandleKeyEvent() {
   ClearEditCommands();
 }
 
 bool RenderViewImpl::WillHandleMouseEvent(const WebKit::WebMouseEvent& event) {
   possible_drag_event_info_.event_source =
       ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
   possible_drag_event_info_.event_location =
       gfx::Point(event.globalX, event.globalY);
-  pepper_delegate_.WillHandleMouseEvent();
+  pepper_delegate_->WillHandleMouseEvent();
 
   // If the mouse is locked, only the current owner of the mouse lock can
   // process mouse events.
   return mouse_lock_dispatcher_->WillHandleMouseEvent(event);
 }
 
 bool RenderViewImpl::WillHandleGestureEvent(
     const WebKit::WebGestureEvent& event) {
   possible_drag_event_info_.event_source =
       ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH;
@@ skipping 22 matching lines @@
   media_player_manager_->ReleaseMediaResources();
 #endif
 
   if (webview()) {
     webview()->settings()->setMinimumTimerInterval(
         webkit_glue::kBackgroundTabTimerInterval);
     webview()->setVisibilityState(visibilityState(), false);
   }
 
   // Inform PPAPI plugins that their page is no longer visible.
-  pepper_delegate_.PageVisibilityChanged(false);
+  pepper_delegate_->PageVisibilityChanged(false);
 
 #if defined(OS_MACOSX)
   // Inform NPAPI plugins that their container is no longer visible.
   std::set<WebPluginDelegateProxy*>::iterator plugin_it;
   for (plugin_it = plugin_delegates_.begin();
        plugin_it != plugin_delegates_.end(); ++plugin_it) {
     (*plugin_it)->SetContainerVisibility(false);
   }
 #endif  // OS_MACOSX
 }
 
 void RenderViewImpl::OnWasShown(bool needs_repainting) {
   RenderWidget::OnWasShown(needs_repainting);
 
   if (webview()) {
     webview()->settings()->setMinimumTimerInterval(
         webkit_glue::kForegroundTabTimerInterval);
     webview()->setVisibilityState(visibilityState(), false);
   }
 
   // Inform PPAPI plugins that their page is visible.
-  pepper_delegate_.PageVisibilityChanged(true);
+  pepper_delegate_->PageVisibilityChanged(true);
 
 #if defined(OS_MACOSX)
   // Inform NPAPI plugins that their container is now visible.
   std::set<WebPluginDelegateProxy*>::iterator plugin_it;
   for (plugin_it = plugin_delegates_.begin();
        plugin_it != plugin_delegates_.end(); ++plugin_it) {
     (*plugin_it)->SetContainerVisibility(true);
   }
 #endif  // OS_MACOSX
 }
@@ skipping 23 matching lines @@
 #if defined(OS_MACOSX)
       // RenderWidget's call to setFocus can cause the underlying webview's
       // activation state to change just like a call to setIsActive.
       if (enable)
         (*plugin_it)->SetWindowFocus(true);
 #endif
       (*plugin_it)->SetContentAreaFocus(enable);
     }
   }
   // Notify all Pepper plugins.
-  pepper_delegate_.OnSetFocus(enable);
+  pepper_delegate_->OnSetFocus(enable);
   // Notify all BrowserPlugins of the RenderView's focus state.
   if (browser_plugin_manager_)
     browser_plugin_manager()->SetEmbedderFocus(this, enable);
 }
 
 void RenderViewImpl::PpapiPluginFocusChanged() {
   UpdateTextInputState(DO_NOT_SHOW_IME);
   UpdateSelectionBounds();
 }
 
 void RenderViewImpl::PpapiPluginTextInputTypeChanged() {
   UpdateTextInputState(DO_NOT_SHOW_IME);
   if (renderer_accessibility_)
     renderer_accessibility_->FocusedNodeChanged(WebNode());
 }
 
 void RenderViewImpl::PpapiPluginCaretPositionChanged() {
   UpdateSelectionBounds();
 }
 
 bool RenderViewImpl::GetPpapiPluginCaretBounds(gfx::Rect* rect) {
-  if (!pepper_delegate_.IsPluginFocused())
+  if (!pepper_delegate_->IsPluginFocused())
     return false;
-  *rect = pepper_delegate_.GetCaretBounds();
+  *rect = pepper_delegate_->GetCaretBounds();
   return true;
 }
 
 void RenderViewImpl::SimulateImeSetComposition(
     const string16& text,
     const std::vector<WebKit::WebCompositionUnderline>& underlines,
     int selection_start,
     int selection_end) {
   OnImeSetComposition(text, underlines, selection_start, selection_end);
 }
@@ skipping 18 matching lines @@
 void RenderViewImpl::PpapiPluginCreated(RendererPpapiHost* host) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_,
                     DidCreatePepperPlugin(host));
 }
 
 void RenderViewImpl::OnImeSetComposition(
     const string16& text,
     const std::vector<WebKit::WebCompositionUnderline>& underlines,
     int selection_start,
     int selection_end) {
-  if (pepper_delegate_.IsPluginFocused()) {
+  if (pepper_delegate_->IsPluginFocused()) {
     // When a PPAPI plugin has focus, we bypass WebKit.
-    pepper_delegate_.OnImeSetComposition(text,
+    pepper_delegate_->OnImeSetComposition(text,
                                          underlines,
                                          selection_start,
                                          selection_end);
   } else {
 #if defined(OS_WIN)
     // When a plug-in has focus, we create platform-specific IME data used by
     // our IME emulator and send it directly to the focused plug-in, i.e. we
     // bypass WebKit. (WebPluginDelegate dispatches this IME data only when its
     // instance ID is the same one as the specified ID.)
     if (focused_plugin_id_ >= 0) {
@@ skipping 19 matching lines @@
 #endif
     RenderWidget::OnImeSetComposition(text,
                                       underlines,
                                       selection_start,
                                       selection_end);
   }
 }
 
 void RenderViewImpl::OnImeConfirmComposition(
       const string16& text, const ui::Range& replacement_range) {
-  if (pepper_delegate_.IsPluginFocused()) {
+  if (pepper_delegate_->IsPluginFocused()) {
     // When a PPAPI plugin has focus, we bypass WebKit.
-    pepper_delegate_.OnImeConfirmComposition(text);
+    pepper_delegate_->OnImeConfirmComposition(text);
   } else {
 #if defined(OS_WIN)
     // Same as OnImeSetComposition(), we send the text from IMEs directly to
     // plug-ins. When we send IME text directly to plug-ins, we should not send
     // it to WebKit to prevent WebKit from controlling IMEs.
     // TODO(thakis): Honor |replacement_range| for plugins?
     if (focused_plugin_id_ >= 0) {
       std::set<WebPluginDelegateProxy*>::iterator it;
       for (it = plugin_delegates_.begin();
            it != plugin_delegates_.end(); ++it) {
@@ skipping 16 matching lines @@
   }
 }
 
 void RenderViewImpl::SetDeviceScaleFactor(float device_scale_factor) {
   RenderWidget::SetDeviceScaleFactor(device_scale_factor);
   if (webview())
     webview()->setDeviceScaleFactor(device_scale_factor);
 }
 
 ui::TextInputType RenderViewImpl::GetTextInputType() {
-  return pepper_delegate_.IsPluginFocused() ?
-      pepper_delegate_.GetTextInputType() : RenderWidget::GetTextInputType();
+  return pepper_delegate_->IsPluginFocused() ?
+      pepper_delegate_->GetTextInputType() : RenderWidget::GetTextInputType();
 }
 
 void RenderViewImpl::GetSelectionBounds(gfx::Rect* start, gfx::Rect* end) {
-  if (pepper_delegate_.IsPluginFocused()) {
+  if (pepper_delegate_->IsPluginFocused()) {
     // TODO(kinaba) http://crbug.com/101101
     // Current Pepper IME API does not handle selection bounds. So we simply
     // use the caret position as an empty range for now. It will be updated
     // after Pepper API equips features related to surrounding text retrieval.
-    gfx::Rect caret = pepper_delegate_.GetCaretBounds();
+    gfx::Rect caret = pepper_delegate_->GetCaretBounds();
     *start = caret;
     *end = caret;
     return;
   }
   RenderWidget::GetSelectionBounds(start, end);
 }
 
 void RenderViewImpl::GetCompositionCharacterBounds(
     std::vector<gfx::Rect>* bounds) {
   DCHECK(bounds);
@@ skipping 18 matching lines @@
     if (!frame->firstRectForCharacterRange(start_offset + i, 1, webrect)) {
       DLOG(ERROR) << "Could not retrieve character rectangle at " << i;
       bounds->clear();
       return;
     }
     bounds->push_back(webrect);
   }
 }
 
 bool RenderViewImpl::CanComposeInline() {
-  return pepper_delegate_.IsPluginFocused() ?
-      pepper_delegate_.CanComposeInline() : true;
+  return pepper_delegate_->IsPluginFocused() ?
+      pepper_delegate_->CanComposeInline() : true;
 }
 
 #if defined(OS_WIN)
 void RenderViewImpl::PluginFocusChanged(bool focused, int plugin_id) {
   if (focused)
     focused_plugin_id_ = plugin_id;
   else
     focused_plugin_id_ = -1;
 }
 #endif
@@ skipping 234 matching lines @@
                                                 size_t request_id) {
   if (request_id != expected_content_intent_id_)
       return;
 
   // Remove the content highlighting if any.
   scheduleComposite();
 
   if (!intent.is_empty())
     Send(new ViewHostMsg_StartContentIntent(routing_id_, intent));
 }
-#endif
+#endif  // defined(OS_ANDROID)
 
 void RenderViewImpl::OnAsyncFileOpened(
     base::PlatformFileError error_code,
     IPC::PlatformFileForTransit file_for_transit,
     int message_id) {
-  pepper_delegate_.OnAsyncFileOpened(
+  pepper_delegate_->OnAsyncFileOpened(
       error_code,
       IPC::PlatformFileForTransitToPlatformFile(file_for_transit),
       message_id);
 }
 
 void RenderViewImpl::OnPpapiBrokerChannelCreated(
     int request_id,
     const IPC::ChannelHandle& handle) {
-  pepper_delegate_.OnPpapiBrokerChannelCreated(request_id,
+  pepper_delegate_->OnPpapiBrokerChannelCreated(request_id,
                                                handle);
 }
 
 void RenderViewImpl::OnPpapiBrokerPermissionResult(
     int request_id,
     bool result) {
-  pepper_delegate_.OnPpapiBrokerPermissionResult(request_id, result);
+  pepper_delegate_->OnPpapiBrokerPermissionResult(request_id, result);
 }
 
 #if defined(OS_MACOSX)
 void RenderViewImpl::OnSelectPopupMenuItem(int selected_index) {
   if (external_popup_menu_ == NULL) {
     // Crash reports from the field indicate that we can be notified with a
     // NULL external popup menu (we probably get notified twice).
     // If you hit this please file a bug against jcivelli and include the page
     // and steps to repro.
     NOTREACHED();
@@ skipping 120 matching lines @@
 }
 #endif
 
 void RenderViewImpl::OnReleaseDisambiguationPopupDIB(
     TransportDIB::Handle dib_handle) {
   TransportDIB* dib = TransportDIB::CreateWithHandle(dib_handle);
   RenderProcess::current()->ReleaseTransportDIB(dib);
 }
 
 }  // namespace content