Refactor GuestView.

chrome/browser/guestview/webview/webview_guest.cc

 // Copyright 2013 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/browser/guestview/webview/webview_guest.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
@@ skipping 112 matching lines @@
       contents);
 #if defined(ENABLE_PLUGINS)
   PluginPermissionHelper::CreateForWebContents(contents);
 #endif
 }
 
 }  // namespace
 
 WebViewGuest::WebViewGuest(WebContents* guest_web_contents,
                            const std::string& extension_id)
-    : GuestView(guest_web_contents, extension_id),
+    : GuestView<WebViewGuest>(guest_web_contents, extension_id),
       WebContentsObserver(guest_web_contents),
       script_executor_(new extensions::ScriptExecutor(guest_web_contents,
                                                       &script_observers_)),
       next_permission_request_id_(0),
       is_overriding_user_agent_(false),
       pending_reload_on_attachment_(false),
       main_frame_id_(0),
       chromevox_injected_(false),
       find_helper_(this),
       javascript_dialog_helper_(this) {
@@ skipping 11 matching lines @@
   CHECK(accessibility_manager);
   accessibility_subscription_ = accessibility_manager->RegisterCallback(
       base::Bind(&WebViewGuest::OnAccessibilityStatusChanged,
                  base::Unretained(this)));
 #endif
 
   AttachWebViewHelpers(guest_web_contents);
 }
 
 // static
-WebViewGuest* WebViewGuest::From(int embedder_process_id,
-                                 int guest_instance_id) {
-  GuestView* guest = GuestView::From(embedder_process_id, guest_instance_id);
-  if (!guest)
-    return NULL;
-  return guest->AsWebView();
-}
-
-// static
-WebViewGuest* WebViewGuest::FromWebContents(WebContents* contents) {
-  GuestView* guest = GuestView::FromWebContents(contents);
-  return guest ? guest->AsWebView() : NULL;
-}
+const std::string& WebViewGuest::Type = "webview";
 
 // static.
 int WebViewGuest::GetViewInstanceId(WebContents* contents) {
   WebViewGuest* guest = FromWebContents(contents);
   if (!guest)
     return guestview::kInstanceIDNone;
 
   return guest->view_instance_id();
 }
 
@@ skipping 90 matching lines @@
 void WebViewGuest::Attach(WebContents* embedder_web_contents,
                           const base::DictionaryValue& args) {
   std::string user_agent_override;
   if (args.GetString(webview::kParameterUserAgentOverride,
                      &user_agent_override)) {
     SetUserAgentOverride(user_agent_override);
   } else {
     SetUserAgentOverride("");
   }
 
-  GuestView::Attach(embedder_web_contents, args);
+  GuestViewBase::Attach(embedder_web_contents, args);
 
   AddWebViewToExtensionRendererState();
 }
 
-GuestView::Type WebViewGuest::GetViewType() const {
-  return GuestView::WEBVIEW;
-}
-
-WebViewGuest* WebViewGuest::AsWebView() {
-  return this;
-}
-
-AdViewGuest* WebViewGuest::AsAdView() {
-  return NULL;
-}
-
 void WebViewGuest::AddMessageToConsole(int32 level,
                                        const base::string16& message,
                                        int32 line_no,
                                        const base::string16& source_id) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   // Log levels are from base/logging.h: LogSeverity.
   args->SetInteger(webview::kLevel, level);
   args->SetString(webview::kMessage, message);
   args->SetInteger(webview::kLine, line_no);
   args->SetString(webview::kSourceId, source_id);
   DispatchEvent(
-      new GuestView::Event(webview::kEventConsoleMessage, args.Pass()));
+      new GuestViewBase::Event(webview::kEventConsoleMessage, args.Pass()));
 }
 
 void WebViewGuest::Close() {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
-  DispatchEvent(new GuestView::Event(webview::kEventClose, args.Pass()));
+  DispatchEvent(new GuestViewBase::Event(webview::kEventClose, args.Pass()));
 }
 
 void WebViewGuest::DidAttach() {
   if (pending_reload_on_attachment_) {
     pending_reload_on_attachment_ = false;
     guest_web_contents()->GetController().Reload(false);
   }
 }
 
 void WebViewGuest::EmbedderDestroyed() {
@@ skipping 24 matching lines @@
 }
 
 void WebViewGuest::GuestProcessGone(base::TerminationStatus status) {
   // Cancel all find sessions in progress.
   find_helper_.CancelAllFindSessions();
 
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
                    guest_web_contents()->GetRenderProcessHost()->GetID());
   args->SetString(webview::kReason, TerminationStatusToString(status));
-  DispatchEvent(
-      new GuestView::Event(webview::kEventExit, args.Pass()));
+  DispatchEvent(new GuestViewBase::Event(webview::kEventExit, args.Pass()));
 }
 
 bool WebViewGuest::HandleKeyboardEvent(
     const content::NativeWebKeyboardEvent& event) {
   if (event.type != blink::WebInputEvent::RawKeyDown)
     return false;
 
 #if defined(OS_MACOSX)
   if (event.modifiers != blink::WebInputEvent::MetaKey)
     return false;
@@ skipping 26 matching lines @@
 }
 
 bool WebViewGuest::IsOverridingUserAgent() const {
   return is_overriding_user_agent_;
 }
 
 void WebViewGuest::LoadProgressed(double progress) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(guestview::kUrl, guest_web_contents()->GetURL().spec());
   args->SetDouble(webview::kProgress, progress);
-  DispatchEvent(new GuestView::Event(webview::kEventLoadProgress, args.Pass()));
+  DispatchEvent(
+      new GuestViewBase::Event(webview::kEventLoadProgress, args.Pass()));
 }
 
 void WebViewGuest::LoadAbort(bool is_top_level,
                              const GURL& url,
                              const std::string& error_type) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetBoolean(guestview::kIsTopLevel, is_top_level);
   args->SetString(guestview::kUrl, url.possibly_invalid_spec());
   args->SetString(guestview::kReason, error_type);
-  DispatchEvent(new GuestView::Event(webview::kEventLoadAbort, args.Pass()));
+  DispatchEvent(
+      new GuestViewBase::Event(webview::kEventLoadAbort, args.Pass()));
 }
 
 // TODO(fsamuel): Find a reliable way to test the 'responsive' and
 // 'unresponsive' events.
 void WebViewGuest::RendererResponsive() {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
       guest_web_contents()->GetRenderProcessHost()->GetID());
-  DispatchEvent(new GuestView::Event(webview::kEventResponsive, args.Pass()));
+  DispatchEvent(
+      new GuestViewBase::Event(webview::kEventResponsive, args.Pass()));
 }
 
 void WebViewGuest::RendererUnresponsive() {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
       guest_web_contents()->GetRenderProcessHost()->GetID());
-  DispatchEvent(new GuestView::Event(webview::kEventUnresponsive, args.Pass()));
+  DispatchEvent(
+      new GuestViewBase::Event(webview::kEventUnresponsive, args.Pass()));
 }
 
 void WebViewGuest::RequestPermission(
     BrowserPluginPermissionType permission_type,
     const base::DictionaryValue& request_info,
     const PermissionResponseCallback& callback,
     bool allowed_by_default) {
   RequestPermissionInternal(permission_type,
                             request_info,
                             callback,
@@ skipping 29 matching lines @@
   }
 }
 
 void WebViewGuest::SetZoom(double zoom_factor) {
   double zoom_level = content::ZoomFactorToZoomLevel(zoom_factor);
   guest_web_contents()->SetZoomLevel(zoom_level);
 
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetDouble(webview::kOldZoomFactor, current_zoom_factor_);
   args->SetDouble(webview::kNewZoomFactor, zoom_factor);
-  DispatchEvent(new GuestView::Event(webview::kEventZoomChange, args.Pass()));
+  DispatchEvent(
+      new GuestViewBase::Event(webview::kEventZoomChange, args.Pass()));
 
   current_zoom_factor_ = zoom_factor;
 }
 
 double WebViewGuest::GetZoom() {
   return current_zoom_factor_;
 }
 
 void WebViewGuest::Find(
     const base::string16& search_text,
@@ skipping 206 matching lines @@
 
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(guestview::kUrl, url.spec());
   args->SetBoolean(guestview::kIsTopLevel, is_main_frame);
   args->SetInteger(webview::kInternalCurrentEntryIndex,
       guest_web_contents()->GetController().GetCurrentEntryIndex());
   args->SetInteger(webview::kInternalEntryCount,
       guest_web_contents()->GetController().GetEntryCount());
   args->SetInteger(webview::kInternalProcessId,
       guest_web_contents()->GetRenderProcessHost()->GetID());
-  DispatchEvent(new GuestView::Event(webview::kEventLoadCommit, args.Pass()));
+  DispatchEvent(
+      new GuestViewBase::Event(webview::kEventLoadCommit, args.Pass()));
 
   // Update the current zoom factor for the new page.
   current_zoom_factor_ = content::ZoomLevelToZoomFactor(
       guest_web_contents()->GetZoomLevel());
 
   if (is_main_frame) {
     chromevox_injected_ = false;
     main_frame_id_ = frame_id;
   }
 }
@@ skipping 16 matching lines @@
     int64 frame_id,
     int64 parent_frame_id,
     bool is_main_frame,
     const GURL& validated_url,
     bool is_error_page,
     bool is_iframe_srcdoc,
     content::RenderViewHost* render_view_host) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(guestview::kUrl, validated_url.spec());
   args->SetBoolean(guestview::kIsTopLevel, is_main_frame);
-  DispatchEvent(new GuestView::Event(webview::kEventLoadStart, args.Pass()));
+  DispatchEvent(
+      new GuestViewBase::Event(webview::kEventLoadStart, args.Pass()));
 }
 
 void WebViewGuest::DocumentLoadedInFrame(
     int64 frame_id,
     content::RenderViewHost* render_view_host) {
   if (frame_id == main_frame_id_)
     InjectChromeVoxIfNeeded(render_view_host);
 }
 
 void WebViewGuest::DidStopLoading(content::RenderViewHost* render_view_host) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
-  DispatchEvent(new GuestView::Event(webview::kEventLoadStop, args.Pass()));
+  DispatchEvent(new GuestViewBase::Event(webview::kEventLoadStop, args.Pass()));
 }
 
 void WebViewGuest::WebContentsDestroyed(WebContents* web_contents) {
   // Clean up custom context menu items for this guest.
   extensions::MenuManager* menu_manager = extensions::MenuManager::Get(
       Profile::FromBrowserContext(browser_context()));
   menu_manager->RemoveAllContextItems(extensions::MenuItem::ExtensionKey(
       embedder_extension_id(), view_instance_id()));
 
   RemoveWebViewFromExtensionRendererState(web_contents);
@@ skipping 10 matching lines @@
     // We cannot reload now because all resource loads are suspended until
     // attachment.
     pending_reload_on_attachment_ = true;
     return;
   }
   guest_web_contents()->GetController().Reload(false);
 }
 
 void WebViewGuest::LoadHandlerCalled() {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
-  DispatchEvent(new GuestView::Event(webview::kEventContentLoad, args.Pass()));
+  DispatchEvent(
+      new GuestViewBase::Event(webview::kEventContentLoad, args.Pass()));
 }
 
 void WebViewGuest::LoadRedirect(const GURL& old_url,
                                 const GURL& new_url,
                                 bool is_top_level) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetBoolean(guestview::kIsTopLevel, is_top_level);
   args->SetString(webview::kNewURL, new_url.spec());
   args->SetString(webview::kOldURL, old_url.spec());
-  DispatchEvent(new GuestView::Event(webview::kEventLoadRedirect, args.Pass()));
+  DispatchEvent(
+      new GuestViewBase::Event(webview::kEventLoadRedirect, args.Pass()));
 }
 
 void WebViewGuest::AddWebViewToExtensionRendererState() {
   const GURL& site_url = guest_web_contents()->GetSiteInstance()->GetSiteURL();
   std::string partition_domain;
   std::string partition_id;
   bool in_memory;
   if (!GetGuestPartitionConfigForSite(
           site_url, &partition_domain, &partition_id, &in_memory)) {
     NOTREACHED();
@@ skipping 41 matching lines @@
   return default_url.Resolve(src);
 }
 
 void WebViewGuest::SizeChanged(const gfx::Size& old_size,
                                const gfx::Size& new_size) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kOldHeight, old_size.height());
   args->SetInteger(webview::kOldWidth, old_size.width());
   args->SetInteger(webview::kNewHeight, new_size.height());
   args->SetInteger(webview::kNewWidth, new_size.width());
-  DispatchEvent(new GuestView::Event(webview::kEventSizeChanged, args.Pass()));
+  DispatchEvent(
+      new GuestViewBase::Event(webview::kEventSizeChanged, args.Pass()));
 }
 
 void WebViewGuest::RequestMediaAccessPermission(
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback) {
   base::DictionaryValue request_info;
   request_info.Set(
       guestview::kUrl,
       base::Value::CreateStringValue(request.security_origin.spec()));
   RequestPermission(static_cast<BrowserPluginPermissionType>(
@@ skipping 113 matching lines @@
     return webview::kInvalidPermissionRequestID;
   }
 
   int request_id = next_permission_request_id_++;
   pending_permission_requests_[request_id] =
       PermissionResponseInfo(callback, permission_type, allowed_by_default);
   scoped_ptr<base::DictionaryValue> args(request_info.DeepCopy());
   args->SetInteger(webview::kRequestId, request_id);
   switch (static_cast<int>(permission_type)) {
     case BROWSER_PLUGIN_PERMISSION_TYPE_NEW_WINDOW: {
-      DispatchEvent(new GuestView::Event(webview::kEventNewWindow,
-                                         args.Pass()));
+      DispatchEvent(
+          new GuestViewBase::Event(webview::kEventNewWindow, args.Pass()));
       break;
     }
     case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG: {
-      DispatchEvent(new GuestView::Event(webview::kEventDialog,
-                                         args.Pass()));
+      DispatchEvent(
+          new GuestViewBase::Event(webview::kEventDialog, args.Pass()));
       break;
     }
     default: {
       args->SetString(webview::kPermission,
                       PermissionTypeToString(permission_type));
-      DispatchEvent(new GuestView::Event(webview::kEventPermissionRequest,
-                                         args.Pass()));
+      DispatchEvent(new GuestViewBase::Event(webview::kEventPermissionRequest,
+                                             args.Pass()));
       break;
     }
   }
   return request_id;
 }
 
 WebViewGuest::PermissionResponseInfo::PermissionResponseInfo()
     : permission_type(BROWSER_PLUGIN_PERMISSION_TYPE_UNKNOWN),
       allowed_by_default(false) {
 }
 
 WebViewGuest::PermissionResponseInfo::PermissionResponseInfo(
     const PermissionResponseCallback& callback,
     BrowserPluginPermissionType permission_type,
     bool allowed_by_default)
     : callback(callback),
       permission_type(permission_type),
       allowed_by_default(allowed_by_default) {
 }
 
 WebViewGuest::PermissionResponseInfo::~PermissionResponseInfo() {
 }