Revert 291002 "Introduce WebViewGuestDelegate."

trunk/src/chrome/browser/guest_view/web_view/web_view_guest.cc

 // Copyright 2014 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/guest_view/web_view/web_view_guest.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
 #include "chrome/browser/extensions/api/web_view/web_view_internal_api.h"
-#include "chrome/browser/guest_view/web_view/chrome_web_view_guest_delegate.h"
+#include "chrome/browser/extensions/chrome_extension_web_contents_observer.h"
+#include "chrome/browser/extensions/menu_manager.h"
+#include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/guest_view/web_view/web_view_constants.h"
 #include "chrome/browser/guest_view/web_view/web_view_permission_helper.h"
 #include "chrome/browser/guest_view/web_view/web_view_permission_types.h"
 #include "chrome/browser/guest_view/web_view/web_view_renderer_state.h"
+#include "chrome/browser/renderer_context_menu/render_view_context_menu.h"
+#include "chrome/browser/ui/pdf/pdf_tab_helper.h"
+#include "chrome/browser/ui/zoom/zoom_controller.h"
+#include "chrome/common/chrome_version_info.h"
+#include "chrome/common/render_messages.h"
+#include "components/renderer_context_menu/context_menu_delegate.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
@@ skipping 12 matching lines @@
 #include "extensions/browser/guest_view/guest_view_constants.h"
 #include "extensions/browser/guest_view/guest_view_manager.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_messages.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
 #include "third_party/WebKit/public/web/WebFindOptions.h"
 #include "ui/base/models/simple_menu_model.h"
 
+#if defined(ENABLE_PRINTING)
+#if defined(ENABLE_FULL_PRINTING)
+#include "chrome/browser/printing/print_preview_message_handler.h"
+#include "chrome/browser/printing/print_view_manager.h"
+#else
+#include "chrome/browser/printing/print_view_manager_basic.h"
+#endif  // defined(ENABLE_FULL_PRINTING)
+#endif  // defined(ENABLE_PRINTING)
+
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
+#endif
+
 using base::UserMetricsAction;
 using content::RenderFrameHost;
 using content::ResourceType;
 using content::WebContents;
 
 namespace extensions {
 
 namespace {
 
 std::string WindowOpenDispositionToString(
@@ skipping 121 matching lines @@
 
 // static
 int WebViewGuest::GetViewInstanceId(WebContents* contents) {
   WebViewGuest* guest = FromWebContents(contents);
   if (!guest)
     return guestview::kInstanceIDNone;
 
   return guest->view_instance_id();
 }
 
+// static
+scoped_ptr<base::ListValue> WebViewGuest::MenuModelToValue(
+    const ui::SimpleMenuModel& menu_model) {
+  scoped_ptr<base::ListValue> items(new base::ListValue());
+  for (int i = 0; i < menu_model.GetItemCount(); ++i) {
+    base::DictionaryValue* item_value = new base::DictionaryValue();
+    // TODO(lazyboy): We need to expose some kind of enum equivalent of
+    // |command_id| instead of plain integers.
+    item_value->SetInteger(webview::kMenuItemCommandId,
+                           menu_model.GetCommandIdAt(i));
+    item_value->SetString(webview::kMenuItemLabel, menu_model.GetLabelAt(i));
+    items->Append(item_value);
+  }
+  return items.Pass();
+}
+
 const char* WebViewGuest::GetAPINamespace() {
   return webview::kAPINamespace;
 }
 
 void WebViewGuest::CreateWebContents(
     const std::string& embedder_extension_id,
     int embedder_render_process_id,
     const base::DictionaryValue& create_params,
     const WebContentsCreatedCallback& callback) {
   content::RenderProcessHost* embedder_render_process_host =
@@ skipping 100 matching lines @@
       new ScriptExecutor(guest_web_contents(), &script_observers_));
 
   notification_registrar_.Add(
       this, content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
       content::Source<WebContents>(guest_web_contents()));
 
   notification_registrar_.Add(
       this, content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
       content::Source<WebContents>(guest_web_contents()));
 
-  if (web_view_guest_delegate_)
-    web_view_guest_delegate_->OnDidInitialize();
+#if defined(OS_CHROMEOS)
+  chromeos::AccessibilityManager* accessibility_manager =
+      chromeos::AccessibilityManager::Get();
+  CHECK(accessibility_manager);
+  accessibility_subscription_ = accessibility_manager->RegisterCallback(
+      base::Bind(&WebViewGuest::OnAccessibilityStatusChanged,
+                 base::Unretained(this)));
+#endif
+
   AttachWebViewHelpers(guest_web_contents());
 }
 
 void WebViewGuest::AttachWebViewHelpers(WebContents* contents) {
-  if (web_view_guest_delegate_)
-    web_view_guest_delegate_->OnAttachWebViewHelpers(contents);
+  // Create a zoom controller for the guest contents give it access to
+  // GetZoomLevel() and and SetZoomLevel() in WebViewGuest.
+  // TODO(wjmaclean) This currently uses the same HostZoomMap as the browser
+  // context, but we eventually want to isolate the guest contents from zoom
+  // changes outside the guest (e.g. in the main browser), so we should
+  // create a separate HostZoomMap for the guest.
+  ZoomController::CreateForWebContents(contents);
+
+  FaviconTabHelper::CreateForWebContents(contents);
+  ChromeExtensionWebContentsObserver::CreateForWebContents(contents);
+#if defined(ENABLE_PRINTING)
+#if defined(ENABLE_FULL_PRINTING)
+  printing::PrintViewManager::CreateForWebContents(contents);
+  printing::PrintPreviewMessageHandler::CreateForWebContents(contents);
+#else
+  printing::PrintViewManagerBasic::CreateForWebContents(contents);
+#endif  // defined(ENABLE_FULL_PRINTING)
+#endif  // defined(ENABLE_PRINTING)
+  PDFTabHelper::CreateForWebContents(contents);
   web_view_permission_helper_.reset(new WebViewPermissionHelper(this));
 }
 
 void WebViewGuest::DidStopLoading() {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventLoadStop, args.Pass()));
 }
 
 void WebViewGuest::EmbedderDestroyed() {
   // TODO(fsamuel): WebRequest event listeners for <webview> should survive
   // reparenting of a <webview> within a single embedder. Right now, we keep
   // around the browser state for the listener for the lifetime of the embedder.
   // Ideally, the lifetime of the listeners should match the lifetime of the
   // <webview> DOM node. Once http://crbug.com/156219 is resolved we can move
   // the call to RemoveWebViewEventListenersOnIOThread back to
   // WebViewGuest::WebContentsDestroyed.
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &RemoveWebViewEventListenersOnIOThread,
           browser_context(), embedder_extension_id(),
           embedder_render_process_id(),
           view_instance_id()));
 }
 
 void WebViewGuest::GuestDestroyed() {
   // Clean up custom context menu items for this guest.
-  if (web_view_guest_delegate_)
-    web_view_guest_delegate_->OnGuestDestroyed();
+  MenuManager* menu_manager = MenuManager::Get(
+      Profile::FromBrowserContext(browser_context()));
+  menu_manager->RemoveAllContextItems(MenuItem::ExtensionKey(
+      embedder_extension_id(), view_instance_id()));
+
   RemoveWebViewStateFromIOThread(web_contents());
 }
 
 void WebViewGuest::GuestReady() {
   // The guest RenderView should always live in an isolated guest process.
   CHECK(guest_web_contents()->GetRenderProcessHost()->IsIsolatedGuest());
   Send(new ExtensionMsg_SetFrameName(
       guest_web_contents()->GetRoutingID(), name_));
 }
 
@@ skipping 49 matching lines @@
                              int number_of_matches,
                              const gfx::Rect& selection_rect,
                              int active_match_ordinal,
                              bool final_update) {
   find_helper_.FindReply(request_id, number_of_matches, selection_rect,
                          active_match_ordinal, final_update);
 }
 
 bool WebViewGuest::HandleContextMenu(
     const content::ContextMenuParams& params) {
-  if (!web_view_guest_delegate_)
-    return false;
-  return web_view_guest_delegate_->HandleContextMenu(params);
+  ContextMenuDelegate* menu_delegate =
+      ContextMenuDelegate::FromWebContents(guest_web_contents());
+  DCHECK(menu_delegate);
+
+  pending_menu_ = menu_delegate->BuildMenu(guest_web_contents(), params);
+
+  // Pass it to embedder.
+  int request_id = ++pending_context_menu_request_id_;
+  scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
+  scoped_ptr<base::ListValue> items =
+      MenuModelToValue(pending_menu_->menu_model());
+  args->Set(webview::kContextMenuItems, items.release());
+  args->SetInteger(webview::kRequestId, request_id);
+  DispatchEventToEmbedder(
+      new GuestViewBase::Event(webview::kEventContextMenu, args.Pass()));
+  return true;
 }
 
 void WebViewGuest::HandleKeyboardEvent(
     WebContents* source,
     const content::NativeWebKeyboardEvent& event) {
   if (!attached())
     return;
 
   if (HandleKeyboardShortcuts(event))
     return;
@@ skipping 118 matching lines @@
                    is_top_level);
       break;
     }
     default:
       NOTREACHED() << "Unexpected notification sent.";
       break;
   }
 }
 
 double WebViewGuest::GetZoom() {
-  if (!web_view_guest_delegate_)
-    return 1.0;
-  return web_view_guest_delegate_->GetZoom();
+  return current_zoom_factor_;
 }
 
 void WebViewGuest::Find(
     const base::string16& search_text,
     const blink::WebFindOptions& options,
     scoped_refptr<WebViewInternalFindFunction> find_function) {
   find_helper_.Find(guest_web_contents(), search_text, options, find_function);
 }
 
 void WebViewGuest::StopFinding(content::StopFindAction action) {
@@ skipping 54 matching lines @@
       content::StoragePartition::OriginMatcherFunction(),
       remove_since,
       base::Time::Now(),
       callback);
   return true;
 }
 
 WebViewGuest::WebViewGuest(content::BrowserContext* browser_context,
                            int guest_instance_id)
     : GuestView<WebViewGuest>(browser_context, guest_instance_id),
+      pending_context_menu_request_id_(0),
       is_overriding_user_agent_(false),
+      chromevox_injected_(false),
+      current_zoom_factor_(1.0),
       find_helper_(this),
       javascript_dialog_helper_(this) {
-  web_view_guest_delegate_.reset(new ChromeWebViewGuestDelegate(this));
 }
 
 WebViewGuest::~WebViewGuest() {
 }
 
 void WebViewGuest::DidCommitProvisionalLoadForFrame(
     content::RenderFrameHost* render_frame_host,
     const GURL& url,
     content::PageTransition transition_type) {
   find_helper_.CancelAllFindSessions();
 
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(guestview::kUrl, url.spec());
   args->SetBoolean(guestview::kIsTopLevel, !render_frame_host->GetParent());
   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());
   DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventLoadCommit, args.Pass()));
-  if (web_view_guest_delegate_) {
-    web_view_guest_delegate_->OnDidCommitProvisionalLoadForFrame(
-        !render_frame_host->GetParent());
-  }
+
+  // Update the current zoom factor for the new page.
+  ZoomController* zoom_controller =
+      ZoomController::FromWebContents(guest_web_contents());
+  DCHECK(zoom_controller);
+  current_zoom_factor_ = zoom_controller->GetZoomLevel();
+
+  if (!render_frame_host->GetParent())
+    chromevox_injected_ = false;
 }
 
 void WebViewGuest::DidFailProvisionalLoad(
     content::RenderFrameHost* render_frame_host,
     const GURL& validated_url,
     int error_code,
     const base::string16& error_description) {
   LoadAbort(!render_frame_host->GetParent(), validated_url,
             net::ErrorToShortString(error_code));
 }
 
 void WebViewGuest::DidStartProvisionalLoadForFrame(
     content::RenderFrameHost* render_frame_host,
     const GURL& validated_url,
     bool is_error_page,
     bool is_iframe_srcdoc) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(guestview::kUrl, validated_url.spec());
   args->SetBoolean(guestview::kIsTopLevel, !render_frame_host->GetParent());
   DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventLoadStart, args.Pass()));
 }
 
 void WebViewGuest::DocumentLoadedInFrame(
     content::RenderFrameHost* render_frame_host) {
-  if (web_view_guest_delegate_)
-    web_view_guest_delegate_->OnDocumentLoadedInFrame(render_frame_host);
+  if (!render_frame_host->GetParent())
+    InjectChromeVoxIfNeeded(render_frame_host->GetRenderViewHost());
 }
 
 bool WebViewGuest::OnMessageReceived(const IPC::Message& message,
                                      RenderFrameHost* render_frame_host) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WebViewGuest, message)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_FrameNameChanged, OnFrameNameChanged)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ skipping 182 matching lines @@
   // As guests do not swap processes on navigation, only navigations to
   // normal web URLs are supported.  No protocol handlers are installed for
   // other schemes (e.g., WebUI or extensions), and no permissions or bindings
   // can be granted to the guest process.
   LoadURLWithParams(validated_url,
                     content::Referrer(),
                     content::PAGE_TRANSITION_AUTO_TOPLEVEL,
                     guest_web_contents());
 }
 
+#if defined(OS_CHROMEOS)
+void WebViewGuest::OnAccessibilityStatusChanged(
+    const chromeos::AccessibilityStatusEventDetails& details) {
+  if (details.notification_type == chromeos::ACCESSIBILITY_MANAGER_SHUTDOWN) {
+    accessibility_subscription_.reset();
+  } else if (details.notification_type ==
+      chromeos::ACCESSIBILITY_TOGGLE_SPOKEN_FEEDBACK) {
+    if (details.enabled)
+      InjectChromeVoxIfNeeded(guest_web_contents()->GetRenderViewHost());
+    else
+      chromevox_injected_ = false;
+  }
+}
+#endif
+
+void WebViewGuest::InjectChromeVoxIfNeeded(
+    content::RenderViewHost* render_view_host) {
+#if defined(OS_CHROMEOS)
+  if (!chromevox_injected_) {
+    chromeos::AccessibilityManager* manager =
+        chromeos::AccessibilityManager::Get();
+    if (manager && manager->IsSpokenFeedbackEnabled()) {
+      manager->InjectChromeVox(render_view_host);
+      chromevox_injected_ = true;
+    }
+  }
+#endif
+}
+
 bool WebViewGuest::HandleKeyboardShortcuts(
     const content::NativeWebKeyboardEvent& event) {
   if (event.type != blink::WebInputEvent::RawKeyDown)
     return false;
 
   // If the user hits the escape key without any modifiers then unlock the
   // mouse if necessary.
   if ((event.windowsKeyCode == ui::VKEY_ESCAPE) &&
       !(event.modifiers & blink::WebInputEvent::InputModifiers)) {
     return guest_web_contents()->GotResponseToLockMouseRequest(false);
@@ skipping 42 matching lines @@
   extra_params()->GetInteger(webview::kAttributeMinHeight, &min_height);
   extra_params()->GetInteger(webview::kAttributeMinWidth, &min_width);
 
   // Call SetAutoSize to apply all the appropriate validation and clipping of
   // values.
   SetAutoSize(auto_size_enabled,
               gfx::Size(min_width, min_height),
               gfx::Size(max_width, max_height));
 }
 
-void WebViewGuest::ShowContextMenu(
-    int request_id,
-    const WebViewGuestDelegate::MenuItemVector* items) {
-  if (web_view_guest_delegate_)
-    web_view_guest_delegate_->OnShowContextMenu(request_id, items);
+void WebViewGuest::ShowContextMenu(int request_id,
+                                   const MenuItemVector* items) {
+  if (!pending_menu_.get())
+    return;
+
+  // Make sure this was the correct request.
+  if (request_id != pending_context_menu_request_id_)
+    return;
+
+  // TODO(lazyboy): Implement.
+  DCHECK(!items);
+
+  ContextMenuDelegate* menu_delegate =
+      ContextMenuDelegate::FromWebContents(guest_web_contents());
+  menu_delegate->ShowMenu(pending_menu_.Pass());
 }
 
 void WebViewGuest::SetName(const std::string& name) {
   if (name_ == name)
     return;
   name_ = name;
 
   Send(new ExtensionMsg_SetFrameName(routing_id(), name_));
 }
 
 void WebViewGuest::SetZoom(double zoom_factor) {
-  if (web_view_guest_delegate_)
-    web_view_guest_delegate_->OnSetZoom(zoom_factor);
+  ZoomController* zoom_controller =
+      ZoomController::FromWebContents(guest_web_contents());
+  DCHECK(zoom_controller);
+  double zoom_level = content::ZoomFactorToZoomLevel(zoom_factor);
+  zoom_controller->SetZoomLevel(zoom_level);
+
+  scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
+  args->SetDouble(webview::kOldZoomFactor, current_zoom_factor_);
+  args->SetDouble(webview::kNewZoomFactor, zoom_factor);
+  DispatchEventToEmbedder(
+      new GuestViewBase::Event(webview::kEventZoomChange, args.Pass()));
+
+  current_zoom_factor_ = zoom_factor;
 }
 
 void WebViewGuest::AddNewContents(content::WebContents* source,
                                   content::WebContents* new_contents,
                                   WindowOpenDisposition disposition,
                                   const gfx::Rect& initial_pos,
                                   bool user_gesture,
                                   bool* was_blocked) {
   if (was_blocked)
     *was_blocked = false;
@@ skipping 137 matching lines @@
   WebViewGuest* guest =
       WebViewGuest::From(embedder_render_process_id(), new_window_instance_id);
   if (!guest)
     return;
 
   if (!allow)
     guest->Destroy();
 }
 
 }  // namespace extensions