Switch to WebFrame from the WebKit API....

chrome/renderer/extensions/event_bindings.cc

 // Copyright (c) 2009 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 "chrome/renderer/extensions/event_bindings.h"
 
 #include "base/basictypes.h"
 #include "base/singleton.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/extensions/bindings_utils.h"
 #include "chrome/renderer/extensions/event_bindings.h"
 #include "chrome/renderer/js_only_v8_extensions.h"
 #include "chrome/renderer/render_thread.h"
 #include "chrome/renderer/render_view.h"
 #include "grit/renderer_resources.h"
 #include "webkit/api/public/WebDataSource.h"
+#include "webkit/api/public/WebFrame.h"
 #include "webkit/api/public/WebURLRequest.h"
-#include "webkit/glue/webframe.h"
 
 using bindings_utils::CallFunctionInContext;
 using bindings_utils::ContextInfo;
 using bindings_utils::ContextList;
 using bindings_utils::GetContexts;
 using bindings_utils::GetStringResource;
 using bindings_utils::ExtensionBase;
 using bindings_utils::GetPendingRequestMap;
 using bindings_utils::PendingRequestMap;
+using WebKit::WebFrame;
 
 namespace {
 
 // Keep a local cache of RenderThread so that we can mock it out for unit tests.
 static RenderThreadBase* render_thread = NULL;
 static bool in_unit_tests = false;
 
 // Set to true if these bindings are registered.  Will be false when extensions
 // are disabled.
 static bool bindings_registered = false;
@@ skipping 153 matching lines @@
 
   NOTREACHED();
 }
 
 void EventBindings::HandleContextCreated(WebFrame* frame, bool content_script) {
   if (!bindings_registered)
     return;
 
   v8::HandleScope handle_scope;
   ContextList& contexts = GetContexts();
-  v8::Local<v8::Context> frame_context = frame->GetMainWorldScriptContext();
+  v8::Local<v8::Context> frame_context = frame->mainWorldScriptContext();
   v8::Local<v8::Context> context = v8::Context::GetCurrent();
   DCHECK(!context.IsEmpty());
   DCHECK(bindings_utils::FindContext(context) == contexts.end());
 
   // Figure out the URL for the toplevel frame.  If the top frame is loading,
   // use its provisional URL, since we get this notification before commit.
-  WebFrame* main_frame = frame->GetView()->GetMainFrame();
-  WebKit::WebDataSource* ds = main_frame->GetProvisionalDataSource();
+  WebFrame* main_frame = frame->view()->GetMainFrame();
+  WebKit::WebDataSource* ds = main_frame->provisionalDataSource();
   if (!ds)
-    ds = main_frame->GetDataSource();
+    ds = main_frame->dataSource();
   GURL url = ds->request().url();
   std::string extension_id;
   if (url.SchemeIs(chrome::kExtensionScheme)) {
     extension_id = url.host();
   } else if (!content_script) {
     // This context is a regular non-extension web page.  Ignore it.  We only
     // care about content scripts and extension frames.
     // (Unless we're in unit tests, in which case we don't care what the URL
     // is).
     DCHECK(frame_context == context);
     if (!in_unit_tests)
       return;
   }
 
   v8::Persistent<v8::Context> persistent_context =
       v8::Persistent<v8::Context>::New(context);
   v8::Persistent<v8::Context> parent_context;
 
   if (content_script) {
     DCHECK(frame_context != context);
 
     parent_context = v8::Persistent<v8::Context>::New(frame_context);
     // Content script contexts can get GCed before their frame goes away, so
     // set up a GC callback.
     persistent_context.MakeWeak(NULL, &ContextWeakReferenceCallback);
   }
 
   RenderView* render_view = NULL;
-  if (frame->GetView() && frame->GetView()->GetDelegate())
-    render_view = static_cast<RenderView*>(frame->GetView()->GetDelegate());
+  if (frame->view() && frame->view()->GetDelegate())
+    render_view = static_cast<RenderView*>(frame->view()->GetDelegate());
 
   contexts.push_back(linked_ptr<ContextInfo>(
       new ContextInfo(persistent_context, extension_id, parent_context,
                       render_view)));
 
   v8::Handle<v8::Value> argv[1];
   argv[0] = v8::String::New(extension_id.c_str());
   CallFunctionInContext(context, "dispatchOnLoad", arraysize(argv), argv);
 }
 
 // static
 void EventBindings::HandleContextDestroyed(WebFrame* frame) {
   if (!bindings_registered)
     return;
 
   v8::HandleScope handle_scope;
-  v8::Local<v8::Context> context = frame->GetMainWorldScriptContext();
+  v8::Local<v8::Context> context = frame->mainWorldScriptContext();
   DCHECK(!context.IsEmpty());
 
   ContextList::iterator context_iter = bindings_utils::FindContext(context);
   if (context_iter != GetContexts().end())
     UnregisterContext(context_iter, false);
 
   // Unload any content script contexts for this frame.  Note that the frame
   // itself might not be registered, but can still be a parent context.
   for (ContextList::iterator it = GetContexts().begin();
        it != GetContexts().end(); ) {
     ContextList::iterator current = it++;
     if ((*current)->parent_context == context)
       UnregisterContext(current, false);
   }
 }
 
 // static
 void EventBindings::CallFunction(const std::string& function_name,
                                  int argc, v8::Handle<v8::Value>* argv,
                                  RenderView* render_view) {
   for (ContextList::iterator it = GetContexts().begin();
        it != GetContexts().end(); ++it) {
     if (render_view && render_view != (*it)->render_view)
       continue;
     CallFunctionInContext((*it)->context, function_name, argc, argv);
   }
 }