Update a few more references to WebFrame to use WebLocalFrame.

content/renderer/gpu/gpu_benchmarking_extension.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/gpu/gpu_benchmarking_extension.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string_number_conversions.h"
 #include "cc/layers/layer.h"
 #include "content/common/input/synthetic_gesture_params.h"
 #include "content/common/input/synthetic_pinch_gesture_params.h"
 #include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
 #include "content/common/input/synthetic_tap_gesture_params.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/v8_value_converter.h"
 #include "content/renderer/gpu/render_widget_compositor.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/skia_benchmarking_extension.h"
-#include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebImageCache.h"
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkGraphics.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkPixelRef.h"
 #include "third_party/skia/include/core/SkStream.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "v8/include/v8.h"
 
 using blink::WebCanvas;
-using blink::WebFrame;
+using blink::WebLocalFrame;
 using blink::WebImageCache;
 using blink::WebPrivatePtr;
 using blink::WebSize;
 using blink::WebView;
 
 const char kGpuBenchmarkingExtensionName[] = "v8/GpuBenchmarking";
 
 // offset parameter is deprecated/ignored, and will be remove from the
 // signature in a future skia release. <reed@google.com>
 static SkData* EncodeBitmapToData(size_t* offset, const SkBitmap& bm) {
@@ skipping 96 matching lines @@
 
 class GpuBenchmarkingContext {
  public:
   GpuBenchmarkingContext()
       : web_frame_(NULL),
         web_view_(NULL),
         render_view_impl_(NULL),
         compositor_(NULL) {}
 
   bool Init(bool init_compositor) {
-    web_frame_ = WebFrame::frameForCurrentContext();
+    web_frame_ = WebLocalFrame::frameForCurrentContext();
     if (!web_frame_)
       return false;
 
     web_view_ = web_frame_->view();
     if (!web_view_) {
       web_frame_ = NULL;
       return false;
     }
 
     render_view_impl_ = RenderViewImpl::FromWebView(web_view_);
@@ skipping 10 matching lines @@
     if (!compositor_) {
       web_frame_ = NULL;
       web_view_ = NULL;
       render_view_impl_ = NULL;
       return false;
     }
 
     return true;
   }
 
-  WebFrame* web_frame() const {
+  WebLocalFrame* web_frame() const {
     DCHECK(web_frame_ != NULL);
     return web_frame_;
   }
   WebView* web_view() const {
     DCHECK(web_view_ != NULL);
     return web_view_;
   }
   RenderViewImpl* render_view_impl() const {
     DCHECK(render_view_impl_ != NULL);
     return render_view_impl_;
   }
   RenderWidgetCompositor* compositor() const {
     DCHECK(compositor_ != NULL);
     return compositor_;
   }
 
  private:
-  WebFrame* web_frame_;
+  WebLocalFrame* web_frame_;
   WebView* web_view_;
   RenderViewImpl* render_view_impl_;
   RenderWidgetCompositor* compositor_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuBenchmarkingContext);
 };
 
 }  // namespace
 
 class GpuBenchmarkingWrapper : public v8::Extension {
@@ skipping 197 matching lines @@
     SkPictureSerializer serializer(dirpath);
     serializer.Serialize(root_layer);
   }
 
   static void OnSyntheticGestureCompleted(
       CallbackAndContext* callback_and_context) {
     v8::Isolate* isolate = callback_and_context->isolate();
     v8::HandleScope scope(isolate);
     v8::Handle<v8::Context> context = callback_and_context->GetContext();
     v8::Context::Scope context_scope(context);
-    WebFrame* frame = WebFrame::frameForContext(context);
+    WebLocalFrame* frame = WebLocalFrame::frameForContext(context);
     if (frame) {
       frame->callFunctionEvenIfScriptDisabled(
           callback_and_context->GetCallback(),
           v8::Object::New(isolate),
           0,
           NULL);
     }
   }
 
   static void SmoothScrollSendsTouch(
@@ skipping 301 matching lines @@
     args.GetReturnValue().Set(true);
   }
 
   static void OnSnapshotCompleted(CallbackAndContext* callback_and_context,
                                   const gfx::Size& size,
                                   const std::vector<unsigned char>& png) {
     v8::Isolate* isolate = callback_and_context->isolate();
     v8::HandleScope scope(isolate);
     v8::Handle<v8::Context> context = callback_and_context->GetContext();
     v8::Context::Scope context_scope(context);
-    WebFrame* frame = WebFrame::frameForContext(context);
+    WebLocalFrame* frame = WebLocalFrame::frameForContext(context);
     if (frame) {
 
       v8::Handle<v8::Value> result;
 
       if(!size.IsEmpty()) {
         v8::Handle<v8::Object> result_object;
         result_object = v8::Object::New(isolate);
 
         result_object->Set(v8::String::NewFromUtf8(isolate, "width"),
                            v8::Number::New(isolate, size.width()));
@@ skipping 52 matching lines @@
     WebImageCache::clear();
   }
 
   static void OnMicroBenchmarkCompleted(
       CallbackAndContext* callback_and_context,
       scoped_ptr<base::Value> result) {
     v8::Isolate* isolate = callback_and_context->isolate();
     v8::HandleScope scope(isolate);
     v8::Handle<v8::Context> context = callback_and_context->GetContext();
     v8::Context::Scope context_scope(context);
-    WebFrame* frame = WebFrame::frameForContext(context);
+    WebLocalFrame* frame = WebLocalFrame::frameForContext(context);
     if (frame) {
       scoped_ptr<V8ValueConverter> converter =
           make_scoped_ptr(V8ValueConverter::create());
       v8::Handle<v8::Value> value = converter->ToV8Value(result.get(), context);
       v8::Handle<v8::Value> argv[] = { value };
 
       frame->callFunctionEvenIfScriptDisabled(
           callback_and_context->GetCallback(),
           v8::Object::New(isolate),
           1,
@@ skipping 43 matching lines @@
     GpuChannelHost* gpu_channel = RenderThreadImpl::current()->GetGpuChannel();
     args.GetReturnValue().Set(!!gpu_channel);
   }
 };
 
 v8::Extension* GpuBenchmarkingExtension::Get() {
   return new GpuBenchmarkingWrapper();
 }
 
 }  // namespace content