BrowserPlugin Cleanup: Simplify update device scale factor

content/renderer/browser_plugin/browser_plugin.cc

 // Copyright 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/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 131 matching lines @@
 bool BrowserPlugin::GetAllowTransparencyAttribute() const {
   return HasDOMAttribute(browser_plugin::kAttributeAllowTransparency);
 }
 
 void BrowserPlugin::ParseAllowTransparencyAttribute() {
   if (!ready())
     return;
 
   bool opaque = !GetAllowTransparencyAttribute();
 
-  if (compositing_helper_.get())

[lazyboy, 2014/09/03 16:58:31]

I think this should stay as is, IIUC we are removing implicit conversion from
scoped_refptr to T*, http://crbug.com/110610

[Fady Samuel, 2014/09/03 17:30:52]

Done.

+  if (compositing_helper_)
     compositing_helper_->SetContentsOpaque(opaque);
 
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetContentsOpaque(
         render_view_routing_id_,
         browser_plugin_instance_id_,
         opaque));
 }
 
 void BrowserPlugin::Attach() {
   if (ready()) {
     attached_ = false;
     guest_crashed_ = false;
     EnableCompositing(false);
-    if (compositing_helper_.get()) {
+    if (compositing_helper_) {
       compositing_helper_->OnContainerDestroy();
       compositing_helper_ = NULL;
     }
   }
 
   // TODO(fsamuel): Add support for reattachment.
   BrowserPluginHostMsg_Attach_Params attach_params;
   attach_params.focused = ShouldGuestBeFocused();
   attach_params.visible = visible_;
   attach_params.opaque = !GetAllowTransparencyAttribute();
   attach_params.origin = plugin_rect().origin();
-  GetSizeParams(&attach_params.resize_guest_params, false);
-
+  gfx::Size view_size(width(), height());
+  if (!view_size.IsEmpty()) {
+    paint_ack_received_ = false;
+    PopulateResizeGuestParameters(view_size,
+                                  &attach_params.resize_guest_params);
+  }
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_Attach(
       render_view_routing_id_,
       browser_plugin_instance_id_,
       attach_params));
 
   attach_pending_ = true;
 }
 
 void BrowserPlugin::DidCommitCompositorFrame() {
-  if (compositing_helper_.get())
+  if (compositing_helper_)
     compositing_helper_->DidCommitCompositorFrame();
 }
 
 void BrowserPlugin::OnAdvanceFocus(int browser_plugin_instance_id,
                                    bool reverse) {
-  DCHECK(render_view_.get());
+  DCHECK(render_view_);
   render_view_->GetWebView()->advanceFocus(reverse);
 }
 
 void BrowserPlugin::OnAttachACK(int browser_plugin_instance_id) {
   DCHECK(!attached());
   attached_ = true;
   attach_pending_ = false;
 }
 
 void BrowserPlugin::OnBuffersSwapped(
@@ skipping 20 matching lines @@
                                                 param.b.producing_route_id,
                                                 param.b.output_surface_id,
                                                 param.b.producing_host_id,
                                                 param.b.shared_memory_handle);
 }
 
 void BrowserPlugin::OnCopyFromCompositingSurface(int browser_plugin_instance_id,
                                                  int request_id,
                                                  gfx::Rect source_rect,
                                                  gfx::Size dest_size) {
-  if (!compositing_helper_.get()) {
+  if (!compositing_helper_) {
     browser_plugin_manager()->Send(
         new BrowserPluginHostMsg_CopyFromCompositingSurfaceAck(
             render_view_routing_id_,
             browser_plugin_instance_id_,
             request_id,
             SkBitmap()));
     return;
   }
   compositing_helper_->CopyFromCompositingSurface(request_id, source_rect,
                                                   dest_size);
@@ skipping 63 matching lines @@
   // resize messages when needed.
   if (params.is_resize_ack)
     paint_ack_received_ = true;
 
   if (params.view_size.width() == width() &&
       params.view_size.height() == height()) {
     return;
   }
 
   BrowserPluginHostMsg_ResizeGuest_Params resize_params;
-  PopulateResizeGuestParameters(&resize_params, plugin_size(), false);
+  PopulateResizeGuestParameters(plugin_size(), &resize_params);
   paint_ack_received_ = false;
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_ResizeGuest(
       render_view_routing_id_,
       browser_plugin_instance_id_,
       resize_params));
 }
 
 NPObject* BrowserPlugin::GetContentWindow() const {
   if (content_window_routing_id_ == MSG_ROUTING_NONE)
     return NULL;
   RenderViewImpl* guest_render_view = RenderViewImpl::FromRoutingID(
       content_window_routing_id_);
   if (!guest_render_view)
     return NULL;
   blink::WebFrame* guest_frame = guest_render_view->GetWebView()->mainFrame();
   return guest_frame->windowObject();
 }
 
 void BrowserPlugin::ShowSadGraphic() {
   // 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();
 }
 
 float BrowserPlugin::GetDeviceScaleFactor() const {
-  if (!render_view_.get())
+  if (!render_view_)
     return 1.0f;
   return render_view_->GetWebView()->deviceScaleFactor();
 }
 
-void BrowserPlugin::UpdateDeviceScaleFactor(float device_scale_factor) {
-  if (last_device_scale_factor_ == device_scale_factor || !paint_ack_received_)
+void BrowserPlugin::UpdateDeviceScaleFactor() {
+  if (!paint_ack_received_ ||
+      last_device_scale_factor_ == GetDeviceScaleFactor()) {
     return;
+  }
 
   BrowserPluginHostMsg_ResizeGuest_Params params;
-  PopulateResizeGuestParameters(&params, plugin_size(), true);
+  PopulateResizeGuestParameters(plugin_size(), &params);
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_ResizeGuest(
       render_view_routing_id_,
       browser_plugin_instance_id_,
       params));
 }
 
 void BrowserPlugin::UpdateGuestFocusState() {
   if (!ready())
     return;
   bool should_be_focused = ShouldGuestBeFocused();
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetFocus(
       render_view_routing_id_,
       browser_plugin_instance_id_,
       should_be_focused));
 }
 
 bool BrowserPlugin::ShouldGuestBeFocused() const {
   bool embedder_focused = false;
-  if (render_view_.get())
+  if (render_view_)
     embedder_focused = render_view_->has_focus();
   return plugin_focused_ && embedder_focused;
 }
 
 WebPluginContainer* BrowserPlugin::container() const {
   return container_;
 }
 
 bool BrowserPlugin::initialize(WebPluginContainer* container) {
   if (!container)
@@ skipping 11 matching lines @@
   // available in render tree.
   browser_plugin_instance_id_ = browser_plugin_manager()->GetNextInstanceID();
   UpdateDOMAttribute("internalinstanceid",
                      base::IntToString(browser_plugin_instance_id_));
 
   browser_plugin_manager()->AddBrowserPlugin(browser_plugin_instance_id_, this);
   return true;
 }
 
 void BrowserPlugin::EnableCompositing(bool enable) {
-  bool enabled = !!compositing_helper_.get();
+  bool enabled = !!compositing_helper_;
   if (enabled == enable)
     return;
 
   if (enable) {
-    DCHECK(!compositing_helper_.get());
-    if (!compositing_helper_.get()) {
+    DCHECK(!compositing_helper_);
+    if (!compositing_helper_) {
       compositing_helper_ = ChildFrameCompositingHelper::CreateForBrowserPlugin(
           weak_ptr_factory_.GetWeakPtr());
     }
   }
   compositing_helper_->EnableCompositing(enable);
   compositing_helper_->SetContentsOpaque(!GetAllowTransparencyAttribute());
 
   if (!enable) {
-    DCHECK(compositing_helper_.get());
+    DCHECK(compositing_helper_);
     compositing_helper_->OnContainerDestroy();
     compositing_helper_ = NULL;
   }
 }
 
 void BrowserPlugin::destroy() {
   // If the plugin was initialized then it has a valid |npp_| identifier, and
   // the |container_| must clear references to the plugin's script objects.
   DCHECK(!npp_ || container_);
   if (container_)
     container_->clearScriptObjects();
 
-  if (compositing_helper_.get())
+  if (compositing_helper_)
     compositing_helper_->OnContainerDestroy();
   container_ = NULL;
   // Will be a no-op if the mouse is not currently locked.
-  if (render_view_.get())
+  if (render_view_)
     render_view_->mouse_lock_dispatcher()->OnLockTargetDestroyed(this);
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 NPObject* BrowserPlugin::scriptableObject() {
   if (!bindings_)
     return NULL;
 
   NPObject* browser_plugin_np_object(bindings_->np_object());
   // The object is expected to be retained before it is returned.
@@ skipping 90 matching lines @@
   // resize.
   if (!paint_ack_received_ ||
       (old_width == window_rect.width && old_height == window_rect.height)) {
     // Let the browser know about the updated view rect.
     browser_plugin_manager()->Send(new BrowserPluginHostMsg_UpdateGeometry(
         render_view_routing_id_, browser_plugin_instance_id_, plugin_rect_));
     return;
   }
 
   BrowserPluginHostMsg_ResizeGuest_Params params;
-  PopulateResizeGuestParameters(&params, plugin_size(), false);
+  PopulateResizeGuestParameters(plugin_size(), &params);
   paint_ack_received_ = false;
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_ResizeGuest(
       render_view_routing_id_,
       browser_plugin_instance_id_,
       params));
 }
 
 void BrowserPlugin::PopulateResizeGuestParameters(
-    BrowserPluginHostMsg_ResizeGuest_Params* params,
     const gfx::Size& view_size,
-    bool needs_repaint) {
+    BrowserPluginHostMsg_ResizeGuest_Params* params) {
   params->size_changed = true;
   params->view_size = view_size;
-  params->repaint = needs_repaint;
   params->scale_factor = GetDeviceScaleFactor();
   if (last_device_scale_factor_ != params->scale_factor) {
-    DCHECK(params->repaint);
     last_device_scale_factor_ = params->scale_factor;
+    params->repaint = true;
   }
 }
 
-void BrowserPlugin::GetSizeParams(
-    BrowserPluginHostMsg_ResizeGuest_Params* resize_guest_params,
-    bool needs_repaint) {
-  gfx::Size view_size(width(), height());
-  if (view_size.IsEmpty())
-    return;
-  paint_ack_received_ = false;
-  PopulateResizeGuestParameters(resize_guest_params, view_size, needs_repaint);
-}
-
 void BrowserPlugin::updateFocus(bool focused) {
   plugin_focused_ = focused;
   UpdateGuestFocusState();
 }
 
 void BrowserPlugin::updateVisibility(bool visible) {
   if (visible_ == visible)
     return;
 
   visible_ = visible;
   if (!ready())
     return;
 
-  if (compositing_helper_.get())
+  if (compositing_helper_)
     compositing_helper_->UpdateVisibility(visible);
 
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetVisibility(
       render_view_routing_id_,
       browser_plugin_instance_id_,
       visible));
 }
 
 bool BrowserPlugin::acceptsInputEvents() {
   return true;
@@ skipping 202 matching lines @@
     const blink::WebMouseEvent& event) {
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_HandleInputEvent(render_view_routing_id_,
                                                 browser_plugin_instance_id_,
                                                 plugin_rect_,
                                                 &event));
   return true;
 }
 
 }  // namespace content