Cache the boolean value in instance variable instead of calling usingDelegatedRenderer

content/browser/renderer_host/render_widget_host_view_android.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/browser/renderer_host/render_widget_host_view_android.h"
 
 #include <android/bitmap.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 137 matching lines @@
       weak_ptr_factory_(this),
       overscroll_effect_enabled_(
           !CommandLine::ForCurrentProcess()->
               HasSwitch(switches::kDisableOverscrollEdgeEffect)),
       overscroll_effect_(OverscrollGlow::Create(overscroll_effect_enabled_)),
       flush_input_requested_(false),
       accelerated_surface_route_id_(0),
       using_synchronous_compositor_(SynchronousCompositorImpl::FromID(
                                         widget_host->GetProcess()->GetID(),
                                         widget_host->GetRoutingID()) != NULL),
-      frame_evictor_(new DelegatedFrameEvictor(this)) {
-  if (!UsingDelegatedRenderer()) {
+      frame_evictor_(new DelegatedFrameEvictor(this)),
+      using_delegated_renderer_(UsingDelegatedRenderer()) {

[no sievers, 2014/02/14 18:42:48]

I'd remove the function now and inline the code here, so that it doesn't
accidentally get called elsewhere instead of using the boolean.

[sivag, 2014/02/17 07:51:13]

Done.

+  if (!using_delegated_renderer_) {
     texture_layer_ = cc::TextureLayer::Create(NULL);
     layer_ = texture_layer_;
   }
 
   host_->SetView(this);
   SetContentViewCore(content_view_core);
   ImageTransportFactoryAndroid::AddObserver(this);
 }
 
 RenderWidgetHostViewAndroid::~RenderWidgetHostViewAndroid() {
@@ skipping 147 matching lines @@
 
 bool RenderWidgetHostViewAndroid::HasValidFrame() const {
   if (!content_view_core_)
     return false;
   if (!layer_)
     return false;
 
   if (texture_size_in_layer_.IsEmpty())
     return false;
 
-  if (UsingDelegatedRenderer()) {
+  if (using_delegated_renderer_) {
     if (!delegated_renderer_layer_.get())
       return false;
   } else {
     if (texture_id_in_layer_ == 0)
       return false;
   }
 
   return true;
 }
 
@@ skipping 508 matching lines @@
 
   if (layer_ && layer_->layer_tree_host()) {
     for (size_t i = 0; i < frame->metadata.latency_info.size(); i++) {
       scoped_ptr<cc::SwapPromise> swap_promise(
           new cc::LatencyInfoSwapPromise(frame->metadata.latency_info[i]));
       layer_->layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
     }
   }
 
   if (frame->delegated_frame_data) {
-    DCHECK(UsingDelegatedRenderer());
+    DCHECK(using_delegated_renderer_);
 
     DCHECK(frame->delegated_frame_data);
     DCHECK(!frame->delegated_frame_data->render_pass_list.empty());
 
     cc::RenderPass* root_pass =
         frame->delegated_frame_data->render_pass_list.back();
     texture_size_in_layer_ = root_pass->output_rect.size();
     ComputeContentsSize(frame->metadata);
 
     SwapDelegatedFrame(output_surface_id, frame->delegated_frame_data.Pass());
     frame_evictor_->SwappedFrame(!host_->is_hidden());
     return;
   }
 
-  DCHECK(!UsingDelegatedRenderer());
+  DCHECK(!using_delegated_renderer_);
 
   if (!frame->gl_frame_data || frame->gl_frame_data->mailbox.IsZero())
     return;
 
   if (output_surface_id != last_output_surface_id_) {
     current_mailbox_ = gpu::Mailbox();
     last_output_surface_id_ = kUndefinedOutputSurfaceId;
   }
 
   base::Closure callback = base::Bind(&InsertSyncPointAndAckForCompositor,
@@ skipping 624 matching lines @@
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content