Browser Plugin: Simplified BrowserPluginManager

content/renderer/browser_plugin/browser_plugin.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.h"
 
 #include "base/json/json_string_value_serializer.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 103 matching lines @@
       min_height_(0),
       min_width_(0),
       process_id_(-1),
       persist_storage_(false),
       valid_partition_id_(true),
       content_window_routing_id_(MSG_ROUTING_NONE),
       plugin_focused_(false),
       embedder_focused_(false),
       visible_(true),
       size_changed_in_flight_(false),
+      browser_plugin_manager_(render_view->browser_plugin_manager()),
       current_nav_entry_index_(0),
       nav_entry_count_(0) {
-  BrowserPluginManager::Get()->AddBrowserPlugin(instance_id, this);
+  browser_plugin_manager()->AddBrowserPlugin(instance_id, this);
   bindings_.reset(new BrowserPluginBindings(this));
 
   ParseAttributes(params);
 }
 
 BrowserPlugin::~BrowserPlugin() {
   if (damage_buffer_)
     FreeDamageBuffer();
-  BrowserPluginManager::Get()->RemoveBrowserPlugin(instance_id_);
-  BrowserPluginManager::Get()->Send(
+  browser_plugin_manager()->RemoveBrowserPlugin(instance_id_);
+  browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_PluginDestroyed(
           render_view_routing_id_,
           instance_id_));
 }
 
 void BrowserPlugin::Cleanup() {
   if (damage_buffer_)
     FreeDamageBuffer();
 }
 
@@ skipping 10 matching lines @@
   // 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
   // acutally need it.
   if (!navigate_src_sent_) {
     BrowserPluginHostMsg_CreateGuest_Params params;
     params.storage_partition_id = storage_partition_id_;
     params.persist_storage = persist_storage_;
     params.focused = ShouldGuestBeFocused();
     params.visible = visible_;
     PopulateAutoSizeParameters(&params.auto_size);
-    BrowserPluginManager::Get()->Send(
+    browser_plugin_manager()->Send(
         new BrowserPluginHostMsg_CreateGuest(
             render_view_routing_id_,
             instance_id_,
             params));
   }
 
   scoped_ptr<BrowserPluginHostMsg_ResizeGuest_Params> params(
       GetPendingResizeParams());
   DCHECK(!params->resize_pending);
 
-  BrowserPluginManager::Get()->Send(
+  browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_NavigateGuest(
           render_view_routing_id_,
           instance_id_,
           src,
           *params));
   // Record that we sent a NavigateGuest message to embedder.
   // Once this instance has navigated, the storage partition cannot be changed,
   // so this value is used for enforcing this.
   navigate_src_sent_ = true;
   src_ = src;
@@ skipping 33 matching lines @@
   if (!auto_size_params.enable) {
     view_width = width();
     view_height = height();
   }
   TransportDIB* new_damage_buffer =
       PopulateResizeGuestParameters(&resize_params, view_width, view_height);
   // AutoSize initiates a resize so we don't want to issue another resize,
   // we just want to make sure the damage buffer has been updated.
   resize_params.resize_pending = true;
   DCHECK(new_damage_buffer);
-  BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_SetAutoSize(
+  browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetAutoSize(
       render_view_routing_id_,
       instance_id_,
       auto_size_params,
       resize_params));
   if (damage_buffer_)
     FreeDamageBuffer();
   damage_buffer_ = new_damage_buffer;
 }
 
 void BrowserPlugin::SizeChangedDueToAutoSize(const gfx::Size& old_view_size) {
@@ skipping 167 matching lines @@
       WebKit::WebString::fromUTF8(internal_name.c_str()),
       false, false,
       WebKit::WebSerializedScriptValue::serialize(
           v8::String::New(json_string.c_str(), json_string.size())));
   container()->element().dispatchEvent(event);
 }
 
 void BrowserPlugin::Back() {
   if (!navigate_src_sent_)
     return;
-  BrowserPluginManager::Get()->Send(
+  browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_Go(render_view_routing_id_,
                                   instance_id_, -1));
 }
 
 void BrowserPlugin::Forward() {
   if (!navigate_src_sent_)
     return;
-  BrowserPluginManager::Get()->Send(
+  browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_Go(render_view_routing_id_,
                                   instance_id_, 1));
 }
 
 void BrowserPlugin::Go(int relative_index) {
   if (!navigate_src_sent_)
     return;
-  BrowserPluginManager::Get()->Send(
+  browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_Go(render_view_routing_id_,
                                   instance_id_,
                                   relative_index));
 }
 
 void BrowserPlugin::TerminateGuest() {
   if (!navigate_src_sent_)
     return;
-  BrowserPluginManager::Get()->Send(
+  browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_TerminateGuest(render_view_routing_id_,
                                               instance_id_));
 }
 
 void BrowserPlugin::Stop() {
   if (!navigate_src_sent_)
     return;
-  BrowserPluginManager::Get()->Send(
+  browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_Stop(render_view_routing_id_,
                                     instance_id_));
 }
 
 void BrowserPlugin::Reload() {
   if (!navigate_src_sent_)
     return;
-  BrowserPluginManager::Get()->Send(
+  browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_Reload(render_view_routing_id_,
                                       instance_id_));
 }
 
 void BrowserPlugin::SetCursor(const WebCursor& cursor) {
   cursor_ = cursor;
 }
 
 void BrowserPlugin::UpdateRect(
     int message_id,
     const BrowserPluginMsg_UpdateRect_Params& params) {
   if ((!auto_size_ &&
        (width() != params.view_size.width() ||
         height() != params.view_size.height())) ||
       (auto_size_ && (!InAutoSizeBounds(params.view_size)))) {
-    BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_UpdateRect_ACK(
+    browser_plugin_manager()->Send(new BrowserPluginHostMsg_UpdateRect_ACK(
         render_view_routing_id_,
         instance_id_,
         message_id,
         gfx::Size(width(), height())));
     return;
   }
   // If the view size has changed since we last updated.
   if (auto_size_ && (params.view_size != last_view_size_)) {
     if (backing_store_)
       backing_store_->Clear(SK_ColorWHITE);
@@ skipping 42 matching lines @@
   for (unsigned i = 0; i < params.copy_rects.size(); i++) {
     backing_store_->PaintToBackingStore(params.bitmap_rect,
                                         params.copy_rects,
                                         damage_buffer_);
   }
   // Invalidate the container.
   // If the BrowserPlugin is scheduled to be deleted, then container_ will be
   // NULL so we shouldn't attempt to access it.
   if (container_)
     container_->invalidate();
-  BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_UpdateRect_ACK(
+  browser_plugin_manager()->Send(new BrowserPluginHostMsg_UpdateRect_ACK(
       render_view_routing_id_,
       instance_id_,
       message_id,
       gfx::Size()));
 }
 
 void BrowserPlugin::GuestGone(int process_id, base::TerminationStatus status) {
   // We fire the event listeners before painting the sad graphic to give the
   // developer an opportunity to display an alternative overlay image on crash.
   std::string termination_status = TerminationStatusToString(status);
@@ skipping 79 matching lines @@
   embedder_focused_ = focused;
 
   if (ShouldGuestBeFocused() != old_guest_focus_state)
     UpdateGuestFocus();
 }
 
 void BrowserPlugin::UpdateGuestFocus() {
   if (!navigate_src_sent_)
     return;
   bool should_be_focused = ShouldGuestBeFocused();
-  BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_SetFocus(
+  browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetFocus(
       render_view_routing_id_,
       instance_id_,
       should_be_focused));
 }
 
 bool BrowserPlugin::ShouldGuestBeFocused() const {
   return plugin_focused_ && embedder_focused_;
 }
 
 void BrowserPlugin::GuestContentWindowReady(int content_window_routing_id) {
@@ skipping 102 matching lines @@
   pending_resize_params_.reset();
 
   scoped_ptr<BrowserPluginHostMsg_ResizeGuest_Params> params(
       new BrowserPluginHostMsg_ResizeGuest_Params);
 
   TransportDIB* new_damage_buffer =
       PopulateResizeGuestParameters(params.get(), width(), height());
   DCHECK(new_damage_buffer);
 
   if (navigate_src_sent_) {
-    BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_ResizeGuest(
+    browser_plugin_manager()->Send(new BrowserPluginHostMsg_ResizeGuest(
         render_view_routing_id_,
         instance_id_,
         *params));
     resize_pending_ = true;
   } else {
     // Until an actual navigation occurs, there is no browser-side embedder
     // present to notify about geometry updates. In this case, after we've
     // updated the BrowserPlugin's state we are done and we do not send a resize
     // message to the browser.
     pending_resize_params_.reset(params.release());
@@ skipping 71 matching lines @@
 TransportDIB* BrowserPlugin::CreateTransportDIB(const size_t size) {
 #if defined(OS_MACOSX)
   TransportDIB::Handle handle;
   // On OSX we don't let the browser manage the transport dib. We manage the
   // deletion of the dib in FreeDamageBuffer().
   IPC::Message* msg = new ViewHostMsg_AllocTransportDIB(
       size,
       false,  // cache in browser.
       &handle);
   TransportDIB* new_damage_buffer = NULL;
-  if (BrowserPluginManager::Get()->Send(msg) && handle.fd >= 0)
+  if (browser_plugin_manager()->Send(msg) && handle.fd >= 0)
     new_damage_buffer = TransportDIB::Map(handle);
 #else
   TransportDIB* new_damage_buffer =
       RenderProcess::current()->CreateTransportDIB(size);
 #endif
   if (!new_damage_buffer)
     NOTREACHED() << "Unable to create damage buffer";
 #if defined(OS_WIN)
   // Windows does not map the buffer by default.
   CHECK(new_damage_buffer->Map());
@@ skipping 16 matching lines @@
 }
 
 void BrowserPlugin::updateVisibility(bool visible) {
   if (visible_ == visible)
     return;
 
   visible_ = visible;
   if (!navigate_src_sent_)
     return;
 
-  BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_SetVisibility(
+  browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetVisibility(
       render_view_routing_id_,
       instance_id_,
       visible));
 }
 
 bool BrowserPlugin::acceptsInputEvents() {
   return true;
 }
 
 bool BrowserPlugin::handleInputEvent(const WebKit::WebInputEvent& event,
                                      WebKit::WebCursorInfo& cursor_info) {
   if (guest_crashed_ || !navigate_src_sent_)
     return false;
   bool handled = false;
   WebCursor cursor;
   IPC::Message* message =
       new BrowserPluginHostMsg_HandleInputEvent(
           render_view_routing_id_,
           &handled);
   message->WriteInt(instance_id_);
   message->WriteData(reinterpret_cast<const char*>(&plugin_rect_),
                      sizeof(gfx::Rect));
   message->WriteData(reinterpret_cast<const char*>(&event), event.size);
-  BrowserPluginManager::Get()->Send(message);
+  browser_plugin_manager()->Send(message);
   cursor_.GetCursorInfo(&cursor_info);
   return handled;
 }
 
 bool BrowserPlugin::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_)
     return false;
-  BrowserPluginManager::Get()->Send(
+  browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_DragStatusUpdate(
         render_view_routing_id_,
         instance_id_,
         drag_status,
         WebDropData(drag_data),
         mask,
         position));
   return false;
 }
 
@@ skipping 14 matching lines @@
                                                  void* notify_data) {
 }
 
 void BrowserPlugin::didFailLoadingFrameRequest(
     const WebKit::WebURL& url,
     void* notify_data,
     const WebKit::WebURLError& error) {
 }
 
 }  // namespace content