Switch to WebFrame from the WebKit API....

chrome/renderer/print_web_view_helper_win.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/print_web_view_helper.h"
 
 #include "app/l10n_util.h"
 #include "base/gfx/size.h"
 #include "base/logging.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/renderer/render_view.h"
 #include "grit/generated_resources.h"
 #include "printing/native_metafile.h"
 #include "webkit/api/public/WebConsoleMessage.h"
-#include "webkit/glue/webframe.h"
+#include "webkit/api/public/WebFrame.h"
 
 using WebKit::WebConsoleMessage;
+using WebKit::WebFrame;
 using WebKit::WebString;
 
 #include "skia/ext/vector_canvas.h"
 
 void PrintWebViewHelper::Print(WebFrame* frame, bool script_initiated) {
   const int kMinSecondsToIgnoreJavascriptInitiatedPrint = 2;
   const int kMaxSecondsToIgnoreJavascriptInitiatedPrint = 2 * 60;  // 2 Minutes.
 
   // If still not finished with earlier print request simply ignore.
   if (IsPrinting())
     return;
 
   // TODO(maruel): Move this out of platform specific code.
   // Check if there is script repeatedly trying to print and ignore it if too
   // frequent.  We use exponential wait time so for a page that calls print() in
   // a loop the user will need to cancel the print dialog after 2 seconds, 4
   // seconds, 8, ... up to the maximum of 2 minutes.
   // This gives the user time to navigate from the page.
   if (script_initiated && (user_cancelled_scripted_print_count_ > 0)) {
     base::TimeDelta diff = base::Time::Now() - last_cancelled_script_print_;
     int min_wait_seconds = std::min(
         kMinSecondsToIgnoreJavascriptInitiatedPrint <<
             (user_cancelled_scripted_print_count_ - 1),
         kMaxSecondsToIgnoreJavascriptInitiatedPrint);
     if (diff.InSeconds() < min_wait_seconds) {
       WebString message(WebString::fromUTF8(
           "Ignoring too frequent calls to print()."));
-      frame->AddMessageToConsole(WebConsoleMessage(
+      frame->addMessageToConsole(WebConsoleMessage(
           WebConsoleMessage::LevelWarning,
           message));
       return;
     }
   }
 
   // Retrieve the default print settings to calculate the expected number of
   // pages.
   ViewMsg_Print_Params default_settings;
   bool user_cancelled_print = false;
@@ skipping 14 matching lines @@
 
     // Continue only if the settings are valid.
     if (default_settings.dpi && default_settings.document_cookie) {
       int expected_pages_count = 0;
 
       // Prepare once to calculate the estimated page count.  This must be in
       // a scope for itself (see comments on PrepareFrameAndViewForPrint).
       {
         PrepareFrameAndViewForPrint prep_frame_view(default_settings,
                                                     frame,
-                                                    frame->GetView());
+                                                    frame->view());
         expected_pages_count = prep_frame_view.GetExpectedPageCount();
         DCHECK(expected_pages_count);
       }
 
       // Ask the browser to show UI to retrieve the final print settings.
       ViewMsg_PrintPages_Params print_settings;
 
       ViewHostMsg_ScriptedPrint_Params params;
 
       // The routing id is sent across as it is needed to look up the
       // corresponding RenderViewHost instance to signal and reset the
       // pump messages event.
       params.routing_id = routing_id();
       // host_window_ may be NULL at this point if the current window is a popup
       // and the print() command has been issued from the parent. The receiver
       // of this message has to deal with this.
       params.host_window_id = render_view_->host_window();
       params.cookie = default_settings.document_cookie;
-      params.has_selection = frame->HasSelection();
+      params.has_selection = frame->hasSelection();
       params.expected_pages_count = expected_pages_count;
 
       msg = new ViewHostMsg_ScriptedPrint(params,
                                           &print_settings);
       msg->set_pump_messages_event(render_view_->modal_dialog_event());
 
       if (Send(msg)) {
         msg = NULL;
 
         // If the settings are invalid, early quit.
@@ skipping 78 matching lines @@
                              0, 0,
                              size_x, size_y,
                              src_bmp.getPixels(),
                              reinterpret_cast<BITMAPINFO*>(&bitmap_header),
                              DIB_RGB_COLORS,
                              SRCCOPY);
   DCHECK(retval != GDI_ERROR);
 #else
   // 100% GDI based.
   skia::VectorCanvas canvas(hdc, size_x, size_y);
-  float webkit_shrink = frame->PrintPage(params.page_number, &canvas);
+  float webkit_shrink = frame->printPage(params.page_number, &canvas);
   if (shrink <= 0) {
     NOTREACHED() << "Printing page " << params.page_number << " failed.";
   } else {
     // Update the dpi adjustment with the "page shrink" calculated in webkit.
     shrink /= webkit_shrink;
   }
 #endif
 
   // Done printing. Close the device context to retrieve the compiled metafile.
   if (!metafile.CloseDc()) {
@@ skipping 34 matching lines @@
   }
   metafile.CloseEmf();
   if (Send(new ViewHostMsg_DuplicateSection(
       routing_id(),
       page_params.metafile_data_handle,
       &page_params.metafile_data_handle))) {
     Send(new ViewHostMsg_DidPrintPage(routing_id(), page_params));
   }
 }