Move <webview> API to chrome layer

content/renderer/browser_plugin/browser_plugin_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/browser_plugin/browser_plugin_impl.h"
 
 #include "base/json/json_string_value_serializer.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
@@ skipping 67 matching lines @@
     WebKit::WebFrame* frame,
     const WebPluginParams& params)
     : instance_id_(browser_plugin::kInstanceIDNone),
       render_view_(render_view->AsWeakPtr()),
       render_view_routing_id_(render_view->GetRoutingID()),
       container_(NULL),
       damage_buffer_sequence_id_(0),
       resize_ack_received_(true),
       sad_guest_(NULL),
       guest_crashed_(false),
-      navigate_src_sent_(false),
+      guest_allocated_(false),
       auto_size_ack_pending_(false),
       guest_process_id_(-1),
       guest_route_id_(-1),
       persist_storage_(false),
       valid_partition_id_(true),
       content_window_routing_id_(MSG_ROUTING_NONE),
       plugin_focused_(false),
       visible_(true),
       size_changed_in_flight_(false),
       allocate_instance_id_sent_(false),
       browser_plugin_manager_(render_view->browser_plugin_manager()),
       current_nav_entry_index_(0),
       nav_entry_count_(0),
       compositing_enabled_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           weak_ptr_factory_(this)) {
-  GetContentClient()->renderer()->BrowserPluginCreated(this);
 }
 
 BrowserPluginImpl::~BrowserPluginImpl() {
   // If the BrowserPlugin has never navigated then the browser process and
   // BrowserPluginManager don't know about it and so there is nothing to do
   // here.
-  if (!navigate_src_sent_)
+  if (!guest_allocated_)
     return;
   browser_plugin_manager()->RemoveBrowserPlugin(instance_id_);
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_PluginDestroyed(render_view_routing_id_,
                                                instance_id_));
 }
 
 void BrowserPluginImpl::AddObserver(BrowserPluginObserver* observer) {
   observers_.AddObserver(observer);
 }
@@ skipping 95 matching lines @@
   min_width = min_width ? min_width : width();
   // For autosize, minWidth should not be bigger than maxWidth.
   return std::min(min_width, GetAdjustedMaxWidth());
 }
 
 std::string BrowserPluginImpl::GetPartitionAttribute() const {
   return GetDOMAttributeValue(browser_plugin::kAttributePartition);
 }
 
 void BrowserPluginImpl::ParseNameAttribute() {
-  if (!navigate_src_sent_)
+  if (!guest_allocated_)
     return;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_SetName(render_view_routing_id_,
                                        instance_id_,
                                        GetNameAttribute()));
 }
 
 bool BrowserPluginImpl::ParseSrcAttribute(std::string* error_message) {
   if (!valid_partition_id_) {
     *error_message = browser_plugin::kErrorInvalidPartition;
     return false;
   }
   std::string src = GetSrcAttribute();
   if (src.empty())
     return true;
 
   // If we haven't created the guest yet, do so now. We will navigate it right
   // after creation. If |src| is empty, we can delay the creation until we
   // actually need it.
-  if (!navigate_src_sent_) {
+  if (!guest_allocated_) {
     // On initial navigation, we request an instance ID from the browser
     // process. We essentially ignore all subsequent calls to SetSrcAttribute
     // until we receive an instance ID. |allocate_instance_id_sent_|
     // prevents BrowserPlugin from allocating more than one instance ID.
     // Upon receiving an instance ID from the browser process, we continue
     // the process of navigation by populating the
     // BrowserPluginHostMsg_CreateGuest_Params with the current state of
     // BrowserPlugin and sending a BrowserPluginHostMsg_CreateGuest to the
     // browser process in order to create a new guest.
     if (!allocate_instance_id_sent_) {
@@ skipping 23 matching lines @@
   if (current_auto_size) {
     params->max_size = gfx::Size(GetAdjustedMaxWidth(), GetAdjustedMaxHeight());
     params->min_size = gfx::Size(GetAdjustedMinWidth(), GetAdjustedMinHeight());
   }
 }
 
 void BrowserPluginImpl::UpdateGuestAutoSizeState(bool current_auto_size) {
   // If we haven't yet heard back from the guest about the last resize request,
   // then we don't issue another request until we do in
   // BrowserPluginImpl::UpdateRect.
-  if (!navigate_src_sent_ || !resize_ack_received_)
+  if (!guest_allocated_ || !resize_ack_received_)
     return;
   BrowserPluginHostMsg_AutoSize_Params auto_size_params;
   BrowserPluginHostMsg_ResizeGuest_Params resize_guest_params;
   if (current_auto_size) {
     GetDamageBufferWithSizeParams(&auto_size_params, &resize_guest_params);
   } else {
     GetDamageBufferWithSizeParams(NULL, &resize_guest_params);
   }
   resize_ack_received_ = false;
   browser_plugin_manager()->Send(
@@ skipping 47 matching lines @@
   GetDamageBufferWithSizeParams(&create_guest_params.auto_size_params,
                                 &create_guest_params.resize_guest_params);
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_CreateGuest(render_view_routing_id_,
                                            instance_id_,
                                            create_guest_params));
 
   // Record that we sent a navigation request to the browser process.
   // Once this instance has navigated, the storage partition cannot be changed,
   // so this value is used for enforcing this.
-  navigate_src_sent_ = true;
+  guest_allocated_ = true;
 }
 
 void BrowserPluginImpl::OnAdvanceFocus(int instance_id, bool reverse) {
   DCHECK(render_view_);
   render_view_->GetWebView()->advanceFocus(reverse);
 }
 
 void BrowserPluginImpl::OnBuffersSwapped(int instance_id,
                                          const gfx::Size& size,
                                          std::string mailbox_name,
@@ skipping 391 matching lines @@
     persist_storage_ = false;
   }
 
   valid_partition_id_ = true;
   storage_partition_id_ = input;
   return true;
 }
 
 bool BrowserPluginImpl::CanRemovePartitionAttribute(
     std::string* error_message) {
-  if (navigate_src_sent_)
+  if (guest_allocated_)
     *error_message = browser_plugin::kErrorCannotRemovePartition;
-  return !navigate_src_sent_;
+  return !guest_allocated_;
 }
 
 void BrowserPluginImpl::ParseAttributes() {
   // TODO(mthiesse): Handle errors here?
   std::string error;
   ParsePartitionAttribute(&error);
 
   // Parse the 'src' attribute last, as it will set the has_navigated_ flag to
   // true, which prevents changing the 'partition' attribute.
   ParseSrcAttribute(&error);
@@ skipping 59 matching lines @@
     // Asynchronously remove item from |alive_v8_permission_request_objects_|.
     // Note that we are using weak pointer for the following PostTask, so we
     // don't need to worry about BrowserPlugin going away.
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&BrowserPluginImpl::OnRequestObjectGarbageCollected,
                    plugin, request_id));
   }
 }
 
-void BrowserPluginImpl::Back() {
-  if (!navigate_src_sent_)
-    return;
-  browser_plugin_manager()->Send(
-      new BrowserPluginHostMsg_Go(render_view_routing_id_,
-                                  instance_id_, -1));
-}
-
-void BrowserPluginImpl::Forward() {
-  if (!navigate_src_sent_)
-    return;
-  browser_plugin_manager()->Send(
-      new BrowserPluginHostMsg_Go(render_view_routing_id_,
-                                  instance_id_, 1));
-}
-
-void BrowserPluginImpl::Go(int relative_index) {
-  if (!navigate_src_sent_)
-    return;
-  browser_plugin_manager()->Send(
-      new BrowserPluginHostMsg_Go(render_view_routing_id_,
-                                  instance_id_,
-                                  relative_index));
-}
-
 void BrowserPluginImpl::TerminateGuest() {
-  if (!navigate_src_sent_ || guest_crashed_)
+  if (!guest_allocated_ || guest_crashed_)
     return;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_TerminateGuest(render_view_routing_id_,
                                               instance_id_));
 }
 
 void BrowserPluginImpl::Stop() {
-  if (!navigate_src_sent_)
+  if (!guest_allocated_)
     return;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_Stop(render_view_routing_id_,
                                     instance_id_));
 }
 
 void BrowserPluginImpl::Reload() {
-  if (!navigate_src_sent_)
+  if (!guest_allocated_)
     return;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_Reload(render_view_routing_id_,
                                       instance_id_));
 }
 
 void BrowserPluginImpl::UpdateGuestFocusState() {
-  if (!navigate_src_sent_)
+  if (!guest_allocated_)
     return;
   bool should_be_focused = ShouldGuestBeFocused();
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetFocus(
       render_view_routing_id_,
       instance_id_,
       should_be_focused));
 }
 
 bool BrowserPluginImpl::ShouldGuestBeFocused() const {
   bool embedder_focused = false;
@@ skipping 44 matching lines @@
   if (!container)
     return false;
 
   if (!GetContentClient()->renderer()->AllowBrowserPlugin(container))
     return false;
 
   bindings_.reset(new BrowserPluginBindings(this));
   container_ = container;
   container_->setWantsWheelEvents(true);
   ParseAttributes();
+  GetContentClient()->renderer()->BrowserPluginCreated(this);
   return true;
 }
 
 void BrowserPluginImpl::EnableCompositing(bool enable) {
   if (compositing_enabled_ == enable)
     return;
 
   compositing_enabled_ = enable;
   if (enable) {
     // No need to keep the backing store and damage buffer around if we're now
@@ skipping 78 matching lines @@
       SkIntToScalar(plugin_rect_.height()));
   canvas->clipRect(image_data_rect);
   // Paint black or white in case we have nothing in our backing store or we
   // need to show a gutter.
   SkPaint paint;
   paint.setStyle(SkPaint::kFill_Style);
   paint.setColor(guest_crashed_ ? SK_ColorBLACK : SK_ColorWHITE);
   canvas->drawRect(image_data_rect, paint);
   // Stay a solid color if we have never set a non-empty src, or we don't have a
   // backing store.
-  if (!backing_store_.get() || !navigate_src_sent_)
+  if (!backing_store_.get() || !guest_allocated_)
     return;
   float inverse_scale_factor =  1.0f / backing_store_->GetScaleFactor();
   canvas->scale(inverse_scale_factor, inverse_scale_factor);
   canvas->drawBitmap(backing_store_->GetBitmap(), 0, 0);
 }
 
 bool BrowserPluginImpl::InBounds(const gfx::Point& position) const {
   // Note that even for plugins that are rotated using rotate transformations,
   // we use the the |plugin_rect_| provided by updateGeometry, which means we
   // will be off if |position| is within the plugin rect but does not fall
   // within the actual plugin boundary. Not supporting such edge case is OK
   // since this function should not be used for making security-sensitive
   // decisions.
   // This also does not take overlapping plugins into account.
   bool result = position.x() >= plugin_rect_.x() &&
       position.x() < plugin_rect_.x() + plugin_rect_.width() &&
       position.y() >= plugin_rect_.y() &&
       position.y() < plugin_rect_.y() + plugin_rect_.height();
   return result;
 }
 
-RenderView* BrowserPluginImpl::GetRenderView() const {
-  return render_view_.get();
-}
-
-WebKit::WebPluginContainer* BrowserPluginImpl::GetContainer() const {
-  return container();
-}
-
 void BrowserPluginImpl::AddMethodBinding(
     BrowserPluginMethodBinding* method_binding) {
   bindings_->AddMethodBinding(method_binding);
 }
 
 void BrowserPluginImpl::AddPropertyBinding(
     BrowserPluginPropertyBinding* method_binding) {
   bindings_->AddPropertyBinding(method_binding);
 }
 
+RenderView* BrowserPluginImpl::GetRenderView() const {
+  return render_view_.get();
+}
+
+int BrowserPluginImpl::GetRoutingID() const {
+  return render_view_routing_id_;
+}
+
+WebKit::WebPluginContainer* BrowserPluginImpl::GetContainer() const {
+  return container();
+}
+
 void BrowserPluginImpl::TriggerEvent(
     const std::string& event_name,
     std::map<std::string, base::Value*>* props) {
   if (!container() || !container()->element().document().frame())
     return;
   v8::HandleScope handle_scope;
   std::string json_string;
   if (props) {
     base::DictionaryValue dict;
     for (std::map<std::string, base::Value*>::iterator iter = props->begin(),
@@ skipping 56 matching lines @@
 
 bool BrowserPluginImpl::HasDOMAttribute(
     const std::string& attribute_name) const {
   if (!container())
     return false;
 
   return container()->element().hasAttribute(
       WebKit::WebString::fromUTF8(attribute_name));
 }
 
-bool BrowserPluginImpl::HasNavigated() const {
-  return navigate_src_sent_;
+bool BrowserPluginImpl::HasGuest() const {
+  return guest_allocated_;
 }
 
 bool BrowserPluginImpl::Send(IPC::Message* message) {
   IPC::Message* wrapper_msg =
       new BrowserPluginHostMsg_ForwardMessage(
           render_view_routing_id_, instance_id_, *message);
   delete message;
   return browser_plugin_manager()->Send(wrapper_msg);
 }
 
@@ skipping 11 matching lines @@
     bool is_visible) {
   int old_width = width();
   int old_height = height();
   plugin_rect_ = window_rect;
   // In AutoSize mode, guests don't care when the BrowserPlugin container is
   // resized. If |!resize_ack_received_|, then we are still waiting on a
   // previous resize to be ACK'ed and so we don't issue additional resizes
   // until the previous one is ACK'ed.
   // TODO(mthiesse): Assess the performance of calling GetAutoSizeAttribute() on
   // resize.
-  if (!navigate_src_sent_ ||
+  if (!guest_allocated_ ||
       !resize_ack_received_ ||
       (old_width == window_rect.width && old_height == window_rect.height) ||
       GetAutoSizeAttribute()) {
     return;
   }
 
   BrowserPluginHostMsg_ResizeGuest_Params params;
   PopulateResizeGuestParameters(&params, gfx::Size(width(), height()));
   resize_ack_received_ = false;
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_ResizeGuest(
@@ skipping 97 matching lines @@
 
   if (ShouldGuestBeFocused() != old_guest_focus_state)
     UpdateGuestFocusState();
 }
 
 void BrowserPluginImpl::updateVisibility(bool visible) {
   if (visible_ == visible)
     return;
 
   visible_ = visible;
-  if (!navigate_src_sent_)
+  if (!guest_allocated_)
     return;
 
   if (compositing_helper_)
     compositing_helper_->UpdateVisibility(visible);
 
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetVisibility(
       render_view_routing_id_,
       instance_id_,
       visible));
 }
 
 bool BrowserPluginImpl::acceptsInputEvents() {
   return true;
 }
 
 bool BrowserPluginImpl::handleInputEvent(const WebKit::WebInputEvent& event,
                                          WebKit::WebCursorInfo& cursor_info) {
-  if (guest_crashed_ || !navigate_src_sent_ ||
+  if (guest_crashed_ || !guest_allocated_ ||
       event.type == WebKit::WebInputEvent::ContextMenu)
     return false;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_HandleInputEvent(render_view_routing_id_,
                                                 instance_id_,
                                                 plugin_rect_,
                                                 &event));
   cursor_.GetCursorInfo(&cursor_info);
   return true;
 }
 
 bool BrowserPluginImpl::handleDragStatusUpdate(
     WebKit::WebDragStatus drag_status,
     const WebKit::WebDragData& drag_data,
     WebKit::WebDragOperationsMask mask,
     const WebKit::WebPoint& position,
     const WebKit::WebPoint& screen) {
-  if (guest_crashed_ || !navigate_src_sent_)
+  if (guest_crashed_ || !guest_allocated_)
     return false;
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_DragStatusUpdate(
       render_view_routing_id_,
       instance_id_,
       drag_status,
       WebDropData(drag_data),
       mask,
       position));
   return false;
 }
@@ skipping 15 matching lines @@
                                                      void* notify_data) {
 }
 
 void BrowserPluginImpl::didFailLoadingFrameRequest(
     const WebKit::WebURL& url,
     void* notify_data,
     const WebKit::WebURLError& error) {
 }
 
 }  // namespace content