Refactor the content interface for RequestMediaAccessPermission.

content/browser/renderer_host/render_view_host_delegate.h

 // 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_VIEW_HOST_DELEGATE_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_VIEW_HOST_DELEGATE_H_
 #pragma once
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/i18n/rtl.h"
 #include "base/process_util.h"
 #include "base/string16.h"
 #include "content/common/content_export.h"
 #include "content/public/common/javascript_message_type.h"
+#include "content/public/common/media_stream_request.h"
 #include "ipc/ipc_channel.h"
 #include "net/base/load_states.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPopupType.h"
 #include "webkit/glue/window_open_disposition.h"
 
 class GURL;
 class SkBitmap;
 class WebContentsImpl;
 class WebKeyboardEvent;
 struct ViewHostMsg_CreateWindow_Params;
@@ skipping 23 matching lines @@
 class RenderViewHostDelegateView;
 class SessionStorageNamespace;
 class WebContents;
 struct ContextMenuParams;
 struct FileChooserParams;
 struct GlobalRequestID;
 struct NativeWebKeyboardEvent;
 struct Referrer;
 struct RendererPreferences;
 
+typedef base::Callback< void(const MediaStreamDevices&) > MediaResponseCallback;
+
 //
 // RenderViewHostDelegate
 //
 //  An interface implemented by an object interested in knowing about the state
 //  of the RenderViewHost.
 //
 //  This interface currently encompasses every type of message that was
 //  previously being sent by WebContents itself. Some of these notifications
 //  may not be relevant to all users of RenderViewHost and we should consider
 //  exposing a more generic Send function on RenderViewHost and a response
@@ skipping 37 matching lines @@
   // IPC::Channel::Listener implementation.
   // This is used to give the delegate a chance to filter IPC messages.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
   // Gets the URL that is currently being displayed, if there is one.
   virtual const GURL& GetURL() const;
 
   // Return this object cast to a WebContents, if it is one. If the object is
   // not a WebContents, returns NULL. DEPRECATED: Be sure to include brettw or
   // jam as reviewers before you use this method. http://crbug.com/82582
-  virtual content::WebContents* GetAsWebContents();
+  virtual WebContents* GetAsWebContents();
 
   // Return the rect where to display the resize corner, if any, otherwise
   // an empty rect.
   virtual gfx::Rect GetRootWindowResizerRect() const = 0;
 
   // The RenderView is being constructed (message sent to the renderer process
   // to construct a RenderView).  Now is a good time to send other setup events
   // to the RenderView.  This precedes any other commands to the RenderView.
   virtual void RenderViewCreated(RenderViewHost* render_view_host) {}
 
   // The RenderView has been constructed.
   virtual void RenderViewReady(RenderViewHost* render_view_host) {}
 
   // The RenderView died somehow (crashed or was killed by the user).
   virtual void RenderViewGone(RenderViewHost* render_view_host,
                               base::TerminationStatus status,
                               int error_code) {}
 
   // The RenderView is going to be deleted. This is called when each
   // RenderView is going to be destroyed
   virtual void RenderViewDeleted(RenderViewHost* render_view_host) {}
 
   // The RenderView started a provisional load for a given frame.
   virtual void DidStartProvisionalLoadForFrame(
-      content::RenderViewHost* render_view_host,
+      RenderViewHost* render_view_host,
       int64 frame_id,
       bool main_frame,
       const GURL& opener_url,
       const GURL& url) {}
 
   // The RenderView processed a redirect during a provisional load.
   //
   // TODO(creis): Remove this method and have the pre-rendering code listen to
   // the ResourceDispatcherHost's RESOURCE_RECEIVED_REDIRECT notification
   // instead.  See http://crbug.com/78512.
   virtual void DidRedirectProvisionalLoad(
-      content::RenderViewHost* render_view_host,
+      RenderViewHost* render_view_host,
       int32 page_id,
       const GURL& opener_url,
       const GURL& source_url,
       const GURL& target_url) {}
 
   // A provisional load in the RenderView failed.
   virtual void DidFailProvisionalLoadWithError(
-      content::RenderViewHost* render_view_host,
+      RenderViewHost* render_view_host,
       const ViewHostMsg_DidFailProvisionalLoadWithError_Params& params) {}
 
   // The RenderView was navigated to a different page.
   virtual void DidNavigate(RenderViewHost* render_view_host,
                            const ViewHostMsg_FrameNavigate_Params& params) {}
 
   // The state for the page changed and should be updated.
   virtual void UpdateState(RenderViewHost* render_view_host,
                            int32 page_id,
                            const std::string& state) {}
@@ skipping 41 matching lines @@
   virtual void DocumentAvailableInMainFrame(RenderViewHost* render_view_host) {}
 
   // The onload handler in the RenderView's main frame has completed.
   virtual void DocumentOnLoadCompletedInMainFrame(
       RenderViewHost* render_view_host,
       int32 page_id) {}
 
   // The page wants to open a URL with the specified disposition.
   virtual void RequestOpenURL(RenderViewHost* rvh,
                               const GURL& url,
-                              const content::Referrer& referrer,
+                              const Referrer& referrer,
                               WindowOpenDisposition disposition,
                               int64 source_frame_id) {}
 
   // The page wants to transfer the request to a new renderer.
   virtual void RequestTransferURL(
       const GURL& url,
-      const content::Referrer& referrer,
+      const Referrer& referrer,
       WindowOpenDisposition disposition,
       int64 source_frame_id,
-      const content::GlobalRequestID& old_request_id) {}
+      const GlobalRequestID& old_request_id) {}
 
   // The page wants to close the active view in this tab.
   virtual void RouteCloseEvent(RenderViewHost* rvh) {}
 
   // The page wants to post a message to the active view in this tab.
   virtual void RouteMessageEvent(
       RenderViewHost* rvh,
       const ViewMsg_PostMessage_Params& params) {}
 
   // A javascript message, confirmation or prompt should be shown.
   virtual void RunJavaScriptMessage(RenderViewHost* rvh,
                                     const string16& message,
                                     const string16& default_prompt,
                                     const GURL& frame_url,
-                                    content::JavaScriptMessageType type,
+                                    JavaScriptMessageType type,
                                     IPC::Message* reply_msg,
                                     bool* did_suppress_message) {}
 
   virtual void RunBeforeUnloadConfirm(RenderViewHost* rvh,
                                       const string16& message,
                                       bool is_reload,
                                       IPC::Message* reply_msg) {}
 
   // A message was added to to the console.
   virtual bool AddMessageToConsole(int32 level,
                                    const string16& message,
                                    int32 line_no,
                                    const string16& source_id);
 
   // Return a dummy RendererPreferences object that will be used by the renderer
   // associated with the owning RenderViewHost.
-  virtual content::RendererPreferences GetRendererPrefs(
-      content::BrowserContext* browser_context) const = 0;
+  virtual RendererPreferences GetRendererPrefs(
+      BrowserContext* browser_context) const = 0;
 
   // Returns a WebPreferences object that will be used by the renderer
   // associated with the owning render view host.
   virtual webkit_glue::WebPreferences GetWebkitPrefs();
 
   // Notification the user has made a gesture while focus was on the
   // page. This is used to avoid uninitiated user downloads (aka carpet
   // bombing), see DownloadRequestLimiter for details.
   virtual void OnUserGesture() {}
 
@@ skipping 34 matching lines @@
   // implementing global 'on hover' features external to the view.
   virtual void HandleMouseMove() {}
   virtual void HandleMouseDown() {}
   virtual void HandleMouseLeave() {}
   virtual void HandleMouseUp() {}
   virtual void HandleMouseActivate() {}
 
   // Called when a file selection is to be done.
   virtual void RunFileChooser(
       RenderViewHost* render_view_host,
-      const content::FileChooserParams& params) {}
+      const FileChooserParams& params) {}
 
   // Notification that the page wants to go into or out of fullscreen mode.
   virtual void ToggleFullscreenMode(bool enter_fullscreen) {}
   virtual bool IsFullscreenForCurrentTab() const;
 
   // The contents' preferred size changed.
   virtual void UpdatePreferredSize(const gfx::Size& pref_size) {}
 
   // The contents auto-resized and the container should match it.
   virtual void ResizeDueToAutoResize(const gfx::Size& new_size) {}
@@ skipping 48 matching lines @@
   // Show the newly created widget with the specified bounds.
   // The widget is identified by the route_id passed to CreateNewWidget.
   virtual void ShowCreatedWidget(int route_id,
                                  const gfx::Rect& initial_pos) {}
 
   // Show the newly created full screen widget. Similar to above.
   virtual void ShowCreatedFullscreenWidget(int route_id) {}
 
   // A context menu should be shown, to be built using the context information
   // provided in the supplied params.
-  virtual void ShowContextMenu(const content::ContextMenuParams& params) {}
+  virtual void ShowContextMenu(const ContextMenuParams& params) {}
+
+  // The render view has requested access to media devices listed in
+  // |request|, and the client should grant or deny that permission by
+  // calling |callback|.
+  virtual void RequestMediaAccessPermission(
+      const MediaStreamRequest* request,
+      const MediaResponseCallback& callback) {}
 
  protected:
   virtual ~RenderViewHostDelegate() {}
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_VIEW_HOST_DELEGATE_H_