Remove WebFrameClient stubs from RenderViewImpl.

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/auto_reset.h"
@@ skipping 2099 matching lines @@
 void RenderViewImpl::initializeLayerTreeView() {
   RenderWidget::initializeLayerTreeView();
   RenderWidgetCompositor* rwc = compositor();
   if (!rwc || !webview() || !webview()->devToolsAgent())
     return;
   webview()->devToolsAgent()->setLayerTreeId(rwc->GetLayerTreeId());
 }
 
 // blink::WebFrameClient -----------------------------------------------------
 
-WebMediaPlayer* RenderViewImpl::createMediaPlayer(
-    WebLocalFrame* frame,
-    const blink::WebURL& url,
-    WebMediaPlayerClient* client) {
-  NOTREACHED();
-  return NULL;
-}
-
 blink::WebMediaPlayer* RenderViewImpl::CreateMediaPlayer(
     RenderFrame* render_frame,
     blink::WebLocalFrame* frame,
     const blink::WebURL& url,
     blink::WebMediaPlayerClient* client) {
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, WillCreateMediaPlayer(frame, client));
 
   WebMediaPlayer* player = CreateWebMediaPlayerForMediaStream(frame, url,
                                                               client);
@@ skipping 383 matching lines @@
 }
 
 void RenderViewImpl::didFinishLoad(WebLocalFrame* frame) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidFinishLoad(frame));
 }
 
 void RenderViewImpl::didUpdateCurrentHistoryItem(WebLocalFrame* frame) {
   StartNavStateSyncTimerIfNecessary();
 }
 
-void RenderViewImpl::willSendRequest(WebLocalFrame* frame,
-                                     unsigned identifier,
-                                     WebURLRequest& request,
-                                     const WebURLResponse& redirect_response) {
-  NOTREACHED();
-}
-
-void RenderViewImpl::didReceiveResponse(WebLocalFrame* frame,
-                                        unsigned identifier,
-                                        const WebURLResponse& response) {
-  NOTREACHED();
-}
-
 void RenderViewImpl::didFinishResourceLoad(WebLocalFrame* frame,
                                            unsigned identifier) {
   InternalDocumentStateData* internal_data =
       InternalDocumentStateData::FromDataSource(frame->dataSource());
   if (!internal_data->use_error_page())
     return;
 
   // Do not show error page when DevTools is attached.
   if (devtools_agent_->IsAttached())
     return;
 
   // Display error page, if appropriate.
   std::string error_domain = "http";
   int http_status_code = internal_data->http_status_code();
   if (GetContentClient()->renderer()->HasErrorPage(
           http_status_code, &error_domain)) {
     WebURLError error;
     error.unreachableURL = frame->document().url();
     error.domain = WebString::fromUTF8(error_domain);
     error.reason = http_status_code;
     LoadNavigationErrorPage(frame, frame->dataSource()->request(), error, true);
   }
 }
 
-void RenderViewImpl::didLoadResourceFromMemoryCache(
-    WebLocalFrame* frame,
-    const WebURLRequest& request,
-    const WebURLResponse& response) {
-  NOTREACHED();
-}
-
-void RenderViewImpl::didDisplayInsecureContent(WebLocalFrame* frame) {
-  NOTREACHED();
-}
-
-void RenderViewImpl::didRunInsecureContent(WebLocalFrame* frame,
-                                           const WebSecurityOrigin& origin,
-                                           const WebURL& target) {
-  NOTREACHED();
-}
-
-void RenderViewImpl::didCreateScriptContext(WebLocalFrame* frame,
-                                            v8::Handle<v8::Context> context,
-                                            int extension_group,
-                                            int world_id) {
-  NOTREACHED();
-}
-
-void RenderViewImpl::willReleaseScriptContext(WebLocalFrame* frame,
-                                              v8::Handle<v8::Context> context,
-                                              int world_id) {
-  NOTREACHED();
-}
-
 void RenderViewImpl::CheckPreferredSize() {
   // We don't always want to send the change messages over IPC, only if we've
   // been put in that mode by getting a |ViewMsg_EnablePreferredSizeChangedMode|
   // message.
   if (!send_preferred_size_changes_ || !webview())
     return;
 
   gfx::Size size = webview()->contentsPreferredMinimumSize();
 
   // In the presence of zoom, these sizes are still reported as if unzoomed,
@@ skipping 88 matching lines @@
 void RenderViewImpl::didChangeScrollOffset(WebLocalFrame* frame) {
   StartNavStateSyncTimerIfNecessary();
 
   if (webview()->mainFrame() == frame)
     UpdateScrollState(frame);
 
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, DidChangeScrollOffset(frame));
 }
 
-void RenderViewImpl::willInsertBody(blink::WebLocalFrame* frame) {
-  NOTREACHED();
-}
-
 void RenderViewImpl::didFirstVisuallyNonEmptyLayout(WebLocalFrame* frame) {
   if (frame != webview()->mainFrame())
     return;
 
   InternalDocumentStateData* data =
       InternalDocumentStateData::FromDataSource(frame->dataSource());
   data->set_did_first_visually_non_empty_layout(true);
 
 #if defined(OS_ANDROID)
   // Update body background color if necessary.
@@ skipping 18 matching lines @@
                                    const WebRect& selection_rect,
                                    bool final_status_update) {
   Send(new ViewHostMsg_Find_Reply(routing_id_,
                                   request_id,
                                   match_count,
                                   selection_rect,
                                   ordinal,
                                   final_status_update));
 }
 
-void RenderViewImpl::reportFindInPageMatchCount(int request_id,
-                                                int count,
-                                                bool final_update) {
-  NOTREACHED();
-}
-
-void RenderViewImpl::reportFindInPageSelection(int request_id,
-                                               int active_match_ordinal,
-                                               const WebRect& selection_rect) {
-  NOTREACHED();
-}
-
-void RenderViewImpl::requestStorageQuota(
-    WebLocalFrame* frame,
-    WebStorageQuotaType type,
-    unsigned long long requested_size,
-    blink::WebStorageQuotaCallbacks callbacks) {
-  NOTREACHED();
-}
-
 bool RenderViewImpl::willCheckAndDispatchMessageEvent(
     blink::WebLocalFrame* sourceFrame,
     blink::WebFrame* targetFrame,
     blink::WebSecurityOrigin target_origin,
     blink::WebDOMMessageEvent event) {
   if (!is_swapped_out_)
     return false;
 
   ViewMsg_PostMessage_Params params;
   params.data = event.data().toString();
@@ skipping 22 matching lines @@
   if (sourceFrame) {
     RenderViewImpl* source_view = FromWebView(sourceFrame->view());
     if (source_view)
       params.source_routing_id = source_view->routing_id();
   }
 
   Send(new ViewHostMsg_RouteMessageEvent(routing_id_, params));
   return true;
 }
 
-void RenderViewImpl::willOpenSocketStream(
-    WebSocketStreamHandle* handle) {
-  NOTREACHED();
-}
-
-void RenderViewImpl::willStartUsingPeerConnectionHandler(
-    blink::WebLocalFrame* frame,
-    blink::WebRTCPeerConnectionHandler* handler) {
-  NOTREACHED();
-}
-
 blink::WebString RenderViewImpl::acceptLanguages() {
   return WebString::fromUTF8(renderer_preferences_.accept_languages);
 }
 
-blink::WebString RenderViewImpl::userAgentOverride(blink::WebLocalFrame* frame,
-                                                   const blink::WebURL& url) {
-  NOTREACHED();
-  return blink::WebString();
-}
-
-WebString RenderViewImpl::doNotTrackValue(WebLocalFrame* frame) {
-  NOTREACHED();
-  return blink::WebString();
-}
-
-bool RenderViewImpl::allowWebGL(WebLocalFrame* frame, bool default_value) {
-  NOTREACHED();
-  return false;
-}
-
-void RenderViewImpl::didLoseWebGLContext(blink::WebLocalFrame* frame,
-                                         int arb_robustness_status_code) {
-  NOTREACHED();
-}
-
 // blink::WebPageSerializerClient implementation ------------------------------
 
 void RenderViewImpl::didSerializeDataForFrame(
     const WebURL& frame_url,
     const WebCString& data,
     WebPageSerializerClient::PageSerializationStatus status) {
   Send(new ViewHostMsg_SendSerializedHtmlData(
     routing_id(),
     frame_url,
     data.data(),
@@ skipping 1844 matching lines @@
     std::vector<gfx::Size> sizes(icon_urls[i].sizes().size());
     ConvertToFaviconSizes(icon_urls[i].sizes(), &sizes);
     if (!url.isEmpty())
       urls.push_back(
           FaviconURL(url, ToFaviconType(icon_urls[i].iconType()), sizes));
   }
   SendUpdateFaviconURL(urls);
 }
 
 }  // namespace content