PPAPI: Run clang_format.py on content/renderer/pepper

content/renderer/pepper/pepper_plugin_instance_impl.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/pepper/pepper_plugin_instance_impl.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 165 matching lines @@
 using blink::WebURLRequest;
 using blink::WebURLResponse;
 using blink::WebUserGestureIndicator;
 using blink::WebUserGestureToken;
 using blink::WebView;
 
 namespace content {
 
 #if defined(OS_WIN)
 // Exported by pdf.dll
-typedef bool (*RenderPDFPageToDCProc)(
-    const unsigned char* pdf_buffer, int buffer_size, int page_number, HDC dc,
-    int dpi_x, int dpi_y, int bounds_origin_x, int bounds_origin_y,
-    int bounds_width, int bounds_height, bool fit_to_bounds,
-    bool stretch_to_bounds, bool keep_aspect_ratio, bool center_in_bounds,
-    bool autorotate);
+typedef bool (*RenderPDFPageToDCProc)(const unsigned char* pdf_buffer,
+                                      int buffer_size,
+                                      int page_number,
+                                      HDC dc,
+                                      int dpi_x,
+                                      int dpi_y,
+                                      int bounds_origin_x,
+                                      int bounds_origin_y,
+                                      int bounds_width,
+                                      int bounds_height,
+                                      bool fit_to_bounds,
+                                      bool stretch_to_bounds,
+                                      bool keep_aspect_ratio,
+                                      bool center_in_bounds,
+                                      bool autorotate);
 
 void DrawEmptyRectangle(HDC dc) {
   // TODO(sanjeevr): This is a temporary hack. If we output a JPEG
   // to the EMF, the EnumEnhMetaFile call fails in the browser
   // process. The failure also happens if we output nothing here.
   // We need to investigate the reason for this failure and fix it.
   // In the meantime this temporary hack of drawing an empty
   // rectangle in the DC gets us by.
   Rectangle(dc, 0, 0, 0, 0);
 }
 #endif  // defined(OS_WIN)
 
 namespace {
 
 // Check PP_TextInput_Type and ui::TextInputType are kept in sync.
-COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_NONE) == \
-    int(PP_TEXTINPUT_TYPE_NONE), mismatching_enums);
-COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_TEXT) == \
-    int(PP_TEXTINPUT_TYPE_TEXT), mismatching_enums);
-COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_PASSWORD) == \
-    int(PP_TEXTINPUT_TYPE_PASSWORD), mismatching_enums);
-COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_SEARCH) == \
-    int(PP_TEXTINPUT_TYPE_SEARCH), mismatching_enums);
-COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_EMAIL) == \
-    int(PP_TEXTINPUT_TYPE_EMAIL), mismatching_enums);
-COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_NUMBER) == \
-    int(PP_TEXTINPUT_TYPE_NUMBER), mismatching_enums);
-COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_TELEPHONE) == \
-    int(PP_TEXTINPUT_TYPE_TELEPHONE), mismatching_enums);
-COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_URL) == \
-    int(PP_TEXTINPUT_TYPE_URL), mismatching_enums);
+COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_NONE) == int(PP_TEXTINPUT_TYPE_NONE),
+               mismatching_enums);
+COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_TEXT) == int(PP_TEXTINPUT_TYPE_TEXT),
+               mismatching_enums);
+COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_PASSWORD) ==
+                   int(PP_TEXTINPUT_TYPE_PASSWORD),
+               mismatching_enums);
+COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_SEARCH) == int(PP_TEXTINPUT_TYPE_SEARCH),
+               mismatching_enums);
+COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_EMAIL) == int(PP_TEXTINPUT_TYPE_EMAIL),
+               mismatching_enums);
+COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_NUMBER) == int(PP_TEXTINPUT_TYPE_NUMBER),
+               mismatching_enums);
+COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_TELEPHONE) ==
+                   int(PP_TEXTINPUT_TYPE_TELEPHONE),
+               mismatching_enums);
+COMPILE_ASSERT(int(ui::TEXT_INPUT_TYPE_URL) == int(PP_TEXTINPUT_TYPE_URL),
+               mismatching_enums);
 
 // The default text input type is to regard the plugin always accept text input.
 // This is for allowing users to use input methods even on completely-IME-
 // unaware plugins (e.g., PPAPI Flash or PDF plugin for M16).
 // Plugins need to explicitly opt out the text input mode if they know
 // that they don't accept texts.
 const ui::TextInputType kPluginDefaultTextInputType = ui::TEXT_INPUT_TYPE_TEXT;
 
-#define COMPILE_ASSERT_MATCHING_ENUM(webkit_name, np_name) \
-    COMPILE_ASSERT(static_cast<int>(WebCursorInfo::webkit_name) \
-                       == static_cast<int>(np_name), \
-                   mismatching_enums)
+#define COMPILE_ASSERT_MATCHING_ENUM(webkit_name, np_name)       \
+  COMPILE_ASSERT(static_cast<int>(WebCursorInfo::webkit_name) == \
+                     static_cast<int>(np_name),                  \
+                 mismatching_enums)
 
-#define COMPILE_ASSERT_PRINT_SCALING_MATCHING_ENUM(webkit_name, pp_name) \
-    COMPILE_ASSERT(static_cast<int>(webkit_name) \
-                       == static_cast<int>(pp_name), \
-                   mismatching_enums)
+#define COMPILE_ASSERT_PRINT_SCALING_MATCHING_ENUM(webkit_name, pp_name)     \
+  COMPILE_ASSERT(static_cast<int>(webkit_name) == static_cast<int>(pp_name), \
+                 mismatching_enums)
 
 // <embed>/<object> attributes.
 const char kWidth[] = "width";
 const char kHeight[] = "height";
 const char kBorder[] = "border";  // According to w3c, deprecated.
 const char kStyle[] = "style";
 
 COMPILE_ASSERT_MATCHING_ENUM(TypePointer, PP_MOUSECURSOR_TYPE_POINTER);
 COMPILE_ASSERT_MATCHING_ENUM(TypeCross, PP_MOUSECURSOR_TYPE_CROSS);
 COMPILE_ASSERT_MATCHING_ENUM(TypeHand, PP_MOUSECURSOR_TYPE_HAND);
@@ skipping 56 matching lines @@
 COMPILE_ASSERT_MATCHING_ENUM(TypeGrabbing, PP_MOUSECURSOR_TYPE_GRABBING);
 // Do not assert WebCursorInfo::TypeCustom == PP_CURSORTYPE_CUSTOM;
 // PP_CURSORTYPE_CUSTOM is pinned to allow new cursor types.
 
 COMPILE_ASSERT_PRINT_SCALING_MATCHING_ENUM(blink::WebPrintScalingOptionNone,
                                            PP_PRINTSCALINGOPTION_NONE);
 COMPILE_ASSERT_PRINT_SCALING_MATCHING_ENUM(
     blink::WebPrintScalingOptionFitToPrintableArea,
     PP_PRINTSCALINGOPTION_FIT_TO_PRINTABLE_AREA);
 COMPILE_ASSERT_PRINT_SCALING_MATCHING_ENUM(
-    blink::WebPrintScalingOptionSourceSize, PP_PRINTSCALINGOPTION_SOURCE_SIZE);
+    blink::WebPrintScalingOptionSourceSize,
+    PP_PRINTSCALINGOPTION_SOURCE_SIZE);
 
 // Sets |*security_origin| to be the WebKit security origin associated with the
 // document containing the given plugin instance. On success, returns true. If
 // the instance is invalid, returns false and |*security_origin| will be
 // unchanged.
 bool SecurityOriginForInstance(PP_Instance instance_id,
                                blink::WebSecurityOrigin* security_origin) {
   PepperPluginInstanceImpl* instance =
       HostGlobals::Get()->GetInstance(instance_id);
   if (!instance)
     return false;
 
   WebElement plugin_element = instance->container()->element();
   *security_origin = plugin_element.document().securityOrigin();
   return true;
 }
 
 // Convert the given vector to an array of C-strings. The strings in the
 // returned vector are only guaranteed valid so long as the vector of strings
 // is not modified.
-scoped_ptr<const char*[]> StringVectorToArgArray(
+scoped_ptr<const char* []> StringVectorToArgArray(
     const std::vector<std::string>& vector) {
-  scoped_ptr<const char*[]> array(new const char*[vector.size()]);
+  scoped_ptr<const char * []> array(new const char* [vector.size()]);
   for (size_t i = 0; i < vector.size(); ++i)
     array[i] = vector[i].c_str();
   return array.Pass();
 }
 
 // Returns true if this is a "system reserved" key which should not be sent to
 // a plugin. Some poorly behaving plugins (like Flash) incorrectly report that
 // they handle all keys sent to them. This can prevent keystrokes from working
 // for things like screen brightness and volume control.
 bool IsReservedSystemInputEvent(const blink::WebInputEvent& event) {
@@ skipping 21 matching lines @@
 
 class PluginInstanceLockTarget : public MouseLockDispatcher::LockTarget {
  public:
   PluginInstanceLockTarget(PepperPluginInstanceImpl* plugin)
       : plugin_(plugin) {}
 
   virtual void OnLockMouseACK(bool succeeded) OVERRIDE {
     plugin_->OnLockMouseACK(succeeded);
   }
 
-  virtual void OnMouseLockLost() OVERRIDE {
-    plugin_->OnMouseLockLost();
-  }
+  virtual void OnMouseLockLost() OVERRIDE { plugin_->OnMouseLockLost(); }
 
-  virtual bool HandleMouseLockedInputEvent(
-      const blink::WebMouseEvent &event) OVERRIDE {
+  virtual bool HandleMouseLockedInputEvent(const blink::WebMouseEvent& event)
+      OVERRIDE {
     plugin_->HandleMouseLockedInputEvent(event);
     return true;
   }
 
  private:
   PepperPluginInstanceImpl* plugin_;
 };
 
-
 }  // namespace
 
 // static
 PepperPluginInstanceImpl* PepperPluginInstanceImpl::Create(
     RenderFrameImpl* render_frame,
     PluginModule* module,
     WebPluginContainer* container,
     const GURL& plugin_url) {
   base::Callback<const void*(const char*)> get_plugin_interface_func =
       base::Bind(&PluginModule::GetPluginInterface, module);
   PPP_Instance_Combined* ppp_instance_combined =
       PPP_Instance_Combined::Create(get_plugin_interface_func);
   if (!ppp_instance_combined)
     return NULL;
-  return new PepperPluginInstanceImpl(render_frame, module,
-                                      ppp_instance_combined, container,
-                                      plugin_url);
+  return new PepperPluginInstanceImpl(
+      render_frame, module, ppp_instance_combined, container, plugin_url);
 }
 
 PepperPluginInstanceImpl::ExternalDocumentLoader::ExternalDocumentLoader()
-    : finished_loading_(false) {
-}
+    : finished_loading_(false) {}
 
-PepperPluginInstanceImpl::ExternalDocumentLoader::~ExternalDocumentLoader() {
-}
+PepperPluginInstanceImpl::ExternalDocumentLoader::~ExternalDocumentLoader() {}
 
 void PepperPluginInstanceImpl::ExternalDocumentLoader::ReplayReceivedData(
     WebURLLoaderClient* document_loader) {
-  for (std::list<std::string>::iterator it = data_.begin();
-       it != data_.end(); ++it) {
-    document_loader->didReceiveData(NULL, it->c_str(), it->length(),
-                                    0 /* encoded_data_length */);
+  for (std::list<std::string>::iterator it = data_.begin(); it != data_.end();
+       ++it) {
+    document_loader->didReceiveData(
+        NULL, it->c_str(), it->length(), 0 /* encoded_data_length */);
   }
   if (finished_loading_) {
-    document_loader->didFinishLoading(NULL, 0 /* finish_time */,
+    document_loader->didFinishLoading(
+        NULL,
+        0 /* finish_time */,
         blink::WebURLLoaderClient::kUnknownEncodedDataLength);
   }
   if (error_.get()) {
     document_loader->didFail(NULL, *error_);
   }
 }
 
 void PepperPluginInstanceImpl::ExternalDocumentLoader::didReceiveData(
     WebURLLoader* loader,
     const char* data,
@@ skipping 11 matching lines @@
 }
 
 void PepperPluginInstanceImpl::ExternalDocumentLoader::didFail(
     WebURLLoader* loader,
     const WebURLError& error) {
   DCHECK(!error_.get());
   error_.reset(new WebURLError(error));
 }
 
 PepperPluginInstanceImpl::GamepadImpl::GamepadImpl()
-    : Resource(ppapi::Resource::Untracked()) {
-}
+    : Resource(ppapi::Resource::Untracked()) {}
 
-PepperPluginInstanceImpl::GamepadImpl::~GamepadImpl() {
-}
+PepperPluginInstanceImpl::GamepadImpl::~GamepadImpl() {}
 
 PPB_Gamepad_API* PepperPluginInstanceImpl::GamepadImpl::AsPPB_Gamepad_API() {
   return this;
 }
 
 void PepperPluginInstanceImpl::GamepadImpl::Sample(
     PP_Instance instance,
     PP_GamepadsSampleData* data) {
   blink::WebGamepads webkit_data;
   RenderThreadImpl::current()->SampleGamepads(&webkit_data);
-  ConvertWebKitGamepadData(
-      bit_cast<ppapi::WebKitGamepads>(webkit_data), data);
+  ConvertWebKitGamepadData(bit_cast<ppapi::WebKitGamepads>(webkit_data), data);
 }
 
 PepperPluginInstanceImpl::PepperPluginInstanceImpl(
     RenderFrameImpl* render_frame,
     PluginModule* module,
     ppapi::PPP_Instance_Combined* instance_interface,
     WebPluginContainer* container,
     const GURL& plugin_url)
     : RenderFrameObserver(render_frame),
       render_frame_(render_frame),
@@ skipping 101 matching lines @@
   DCHECK(!fullscreen_container_);
 
   // Free all the plugin objects. This will automatically clear the back-
   // pointer from the NPObject so WebKit can't call into the plugin any more.
   //
   // Swap out the set so we can delete from it (the objects will try to
   // unregister themselves inside the delete call).
   PluginObjectSet plugin_object_copy;
   live_plugin_objects_.swap(plugin_object_copy);
   for (PluginObjectSet::iterator i = plugin_object_copy.begin();
-       i != plugin_object_copy.end(); ++i)
+       i != plugin_object_copy.end();
+       ++i)
     delete *i;
 
   if (TrackedCallback::IsPending(lock_mouse_callback_))
     lock_mouse_callback_->Abort();
 
   if (!instance_deleted_callback_.is_null())
     instance_deleted_callback_.Run();
 
   if (!module_->IsProxied() && render_frame_) {
     PepperBrowserConnection* browser_connection =
@@ skipping 49 matching lines @@
     fullscreen_container_ = NULL;
   }
 
   // Force-unbind any Graphics. In the case of Graphics2D, if the plugin
   // leaks the graphics 2D, it may actually get cleaned up after our
   // destruction, so we need its pointers to be up-to-date.
   BindGraphics(pp_instance(), 0);
   container_ = NULL;
 }
 
-bool PepperPluginInstanceImpl::is_deleted() const {
-  return is_deleted_;
-}
+bool PepperPluginInstanceImpl::is_deleted() const { return is_deleted_; }
 
 void PepperPluginInstanceImpl::Paint(WebCanvas* canvas,
                                      const gfx::Rect& plugin_rect,
                                      const gfx::Rect& paint_rect) {
   TRACE_EVENT0("ppapi", "PluginInstance::Paint");
   if (module()->is_crashed()) {
     // Crashed plugin painting.
     if (!sad_plugin_)  // Lazily initialize bitmap.
       sad_plugin_ = GetContentClient()->renderer()->GetSadPluginBitmap();
     if (sad_plugin_)
       PaintSadPlugin(canvas, plugin_rect, *sad_plugin_);
     return;
   }
 
   if (bound_graphics_2d_platform_)
     bound_graphics_2d_platform_->Paint(canvas, plugin_rect, paint_rect);
 }
 
 void PepperPluginInstanceImpl::InvalidateRect(const gfx::Rect& rect) {
   if (fullscreen_container_) {
     if (rect.IsEmpty())
       fullscreen_container_->Invalidate();
     else
       fullscreen_container_->InvalidateRect(rect);
   } else {
-    if (!container_ ||
-        view_data_.rect.size.width == 0 || view_data_.rect.size.height == 0)
+    if (!container_ || view_data_.rect.size.width == 0 ||
+        view_data_.rect.size.height == 0)
       return;  // Nothing to do.
     if (rect.IsEmpty())
       container_->invalidate();
     else
       container_->invalidateRect(rect);
   }
   if (texture_layer_) {
     if (rect.IsEmpty()) {
       texture_layer_->SetNeedsDisplay();
     } else {
@@ skipping 52 matching lines @@
   }
 
   if (render_frame_)
     render_frame_->PluginCrashed(module_->path(), module_->GetPeerProcessId());
   UnSetAndDeleteLockTargetAdapter();
 }
 
 static void SetGPUHistogram(const ppapi::Preferences& prefs,
                             const std::vector<std::string>& arg_names,
                             const std::vector<std::string>& arg_values) {
-  // Calculate a histogram to let us determine how likely people are to try to
-  // run Stage3D content on machines that have it blacklisted.
+// Calculate a histogram to let us determine how likely people are to try to
+// run Stage3D content on machines that have it blacklisted.

[bbudge, 2014/04/07 17:02:17]

Comment aligned to #if here, probably should be moved after #if.
I'm not suggesting any changes to the CL however.

 #if defined(OS_WIN)
   bool needs_gpu = false;
   bool is_xp = base::win::GetVersion() <= base::win::VERSION_XP;
 
   for (size_t i = 0; i < arg_names.size(); i++) {
     if (arg_names[i] == "wmode") {
       // In theory content other than Flash could have a "wmode" argument,
       // but that's pretty unlikely.
       if (arg_values[i] == "direct" || arg_values[i] == "gpu")
         needs_gpu = true;
       break;
     }
   }
   // 0 : No 3D content and GPU is blacklisted
   // 1 : No 3D content and GPU is not blacklisted
   // 2 : 3D content but GPU is blacklisted
   // 3 : 3D content and GPU is not blacklisted
   // 4 : No 3D content and GPU is blacklisted on XP
   // 5 : No 3D content and GPU is not blacklisted on XP
   // 6 : 3D content but GPU is blacklisted on XP
   // 7 : 3D content and GPU is not blacklisted on XP
-  UMA_HISTOGRAM_ENUMERATION("Flash.UsesGPU",
-      is_xp * 4 + needs_gpu * 2 + prefs.is_webgl_supported, 8);
+  UMA_HISTOGRAM_ENUMERATION(
+      "Flash.UsesGPU", is_xp * 4 + needs_gpu * 2 + prefs.is_webgl_supported, 8);
 #endif
 }
 
 bool PepperPluginInstanceImpl::Initialize(
     const std::vector<std::string>& arg_names,
     const std::vector<std::string>& arg_values,
     bool full_frame) {
   if (!render_frame_)
     return false;
   message_channel_.reset(new MessageChannel(this));
 
   full_frame_ = full_frame;
 
   UpdateTouchEventRequest();
   container_->setWantsWheelEvents(IsAcceptingWheelEvents());
 
-  SetGPUHistogram(ppapi::Preferences(
-      render_frame_->render_view()->webkit_preferences()),
-      arg_names, arg_values);
+  SetGPUHistogram(
+      ppapi::Preferences(render_frame_->render_view()->webkit_preferences()),
+      arg_names,
+      arg_values);
 
   argn_ = arg_names;
   argv_ = arg_values;
-  scoped_ptr<const char*[]> argn_array(StringVectorToArgArray(argn_));
-  scoped_ptr<const char*[]> argv_array(StringVectorToArgArray(argv_));
-  bool success =  PP_ToBool(instance_interface_->DidCreate(pp_instance(),
-                                                           argn_.size(),
-                                                           argn_array.get(),
-                                                           argv_array.get()));
+  scoped_ptr<const char * []> argn_array(StringVectorToArgArray(argn_));
+  scoped_ptr<const char * []> argv_array(StringVectorToArgArray(argv_));
+  bool success = PP_ToBool(instance_interface_->DidCreate(
+      pp_instance(), argn_.size(), argn_array.get(), argv_array.get()));
   if (success)
     message_channel_->StopQueueingJavaScriptMessages();
   return success;
 }
 
 bool PepperPluginInstanceImpl::HandleDocumentLoad(
     const blink::WebURLResponse& response) {
   DCHECK(!document_loader_);
   if (external_document_load_) {
     // The external proxy isn't available, so save the response and record
@@ skipping 41 matching lines @@
                  response,
                  pending_host_id));
 
   // If the load was not abandoned, document_loader_ will now be set. It's
   // possible that the load was canceled by now and document_loader_ was
   // already nulled out.
   return true;
 }
 
 bool PepperPluginInstanceImpl::SendCompositionEventToPlugin(
-    PP_InputEvent_Type type, const base::string16& text) {
+    PP_InputEvent_Type type,
+    const base::string16& text) {
   std::vector<blink::WebCompositionUnderline> empty;
   return SendCompositionEventWithUnderlineInformationToPlugin(
-      type, text, empty, static_cast<int>(text.size()),
+      type,
+      text,
+      empty,
+      static_cast<int>(text.size()),
       static_cast<int>(text.size()));
 }
 
-bool PepperPluginInstanceImpl::
-    SendCompositionEventWithUnderlineInformationToPlugin(
-        PP_InputEvent_Type type,
-        const base::string16& text,
-        const std::vector<blink::WebCompositionUnderline>& underlines,
-        int selection_start,
-        int selection_end) {
+bool
+PepperPluginInstanceImpl::SendCompositionEventWithUnderlineInformationToPlugin(
+    PP_InputEvent_Type type,
+    const base::string16& text,
+    const std::vector<blink::WebCompositionUnderline>& underlines,
+    int selection_start,
+    int selection_end) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PepperPluginInstanceImpl> ref(this);
 
   if (!LoadInputEventInterface())
     return false;
 
   PP_InputEvent_Class event_class = PP_INPUTEVENT_CLASS_IME;
   if (!(filtered_input_event_mask_ & event_class) &&
       !(input_event_mask_ & event_class))
     return false;
 
   ppapi::InputEventData event;
   event.event_type = type;
-  event.event_time_stamp = ppapi::TimeTicksToPPTimeTicks(
-      base::TimeTicks::Now());
+  event.event_time_stamp =
+      ppapi::TimeTicksToPPTimeTicks(base::TimeTicks::Now());
 
   // Convert UTF16 text to UTF8 with offset conversion.
   std::vector<size_t> utf16_offsets;
   utf16_offsets.push_back(selection_start);
   utf16_offsets.push_back(selection_end);
   for (size_t i = 0; i < underlines.size(); ++i) {
     utf16_offsets.push_back(underlines[i].startOffset);
     utf16_offsets.push_back(underlines[i].endOffset);
   }
   std::vector<size_t> utf8_offsets(utf16_offsets);
   event.character_text = base::UTF16ToUTF8AndAdjustOffsets(text, &utf8_offsets);
 
   // Set the converted selection range.
-  event.composition_selection_start = (utf8_offsets[0] == std::string::npos ?
-      event.character_text.size() : utf8_offsets[0]);
-  event.composition_selection_end = (utf8_offsets[1] == std::string::npos ?
-      event.character_text.size() : utf8_offsets[1]);
+  event.composition_selection_start =
+      (utf8_offsets[0] == std::string::npos ? event.character_text.size()
+                                            : utf8_offsets[0]);
+  event.composition_selection_end =
+      (utf8_offsets[1] == std::string::npos ? event.character_text.size()
+                                            : utf8_offsets[1]);
 
   // Set the converted segmentation points.
   // Be sure to add 0 and size(), and remove duplication or errors.
-  std::set<size_t> offset_set(utf8_offsets.begin()+2, utf8_offsets.end());
+  std::set<size_t> offset_set(utf8_offsets.begin() + 2, utf8_offsets.end());
   offset_set.insert(0);
   offset_set.insert(event.character_text.size());
   offset_set.erase(std::string::npos);
   event.composition_segment_offsets.assign(offset_set.begin(),
                                            offset_set.end());
 
   // Set the composition target.
   for (size_t i = 0; i < underlines.size(); ++i) {
     if (underlines[i].thick) {
       std::vector<uint32_t>::iterator it =
           std::find(event.composition_segment_offsets.begin(),
                     event.composition_segment_offsets.end(),
-                    utf8_offsets[2*i+2]);
+                    utf8_offsets[2 * i + 2]);
       if (it != event.composition_segment_offsets.end()) {
         event.composition_target_segment =
             it - event.composition_segment_offsets.begin();
         break;
       }
     }
   }
 
   // Send the event.
   bool handled = false;
@@ skipping 22 matching lines @@
                                       text);
 }
 
 bool PepperPluginInstanceImpl::HandleCompositionUpdate(
     const base::string16& text,
     const std::vector<blink::WebCompositionUnderline>& underlines,
     int selection_start,
     int selection_end) {
   return SendCompositionEventWithUnderlineInformationToPlugin(
       PP_INPUTEVENT_TYPE_IME_COMPOSITION_UPDATE,
-      text, underlines, selection_start, selection_end);
+      text,
+      underlines,
+      selection_start,
+      selection_end);
 }
 
 bool PepperPluginInstanceImpl::HandleCompositionEnd(
     const base::string16& text) {
   return SendCompositionEventToPlugin(PP_INPUTEVENT_TYPE_IME_COMPOSITION_END,
                                       text);
 }
 
 bool PepperPluginInstanceImpl::HandleTextInput(const base::string16& text) {
-  return SendCompositionEventToPlugin(PP_INPUTEVENT_TYPE_IME_TEXT,
-                                      text);
+  return SendCompositionEventToPlugin(PP_INPUTEVENT_TYPE_IME_TEXT, text);
 }
 
 void PepperPluginInstanceImpl::GetSurroundingText(base::string16* text,
                                                   gfx::Range* range) const {
   std::vector<size_t> offsets;
   offsets.push_back(selection_anchor_);
   offsets.push_back(selection_caret_);
   *text = base::UTF8ToUTF16AndAdjustOffsets(surrounding_text_, &offsets);
   range->set_start(offsets[0] == base::string16::npos ? text->size()
                                                       : offsets[0]);
   range->set_end(offsets[1] == base::string16::npos ? text->size()
                                                     : offsets[1]);
 }
 
 bool PepperPluginInstanceImpl::IsPluginAcceptingCompositionEvents() const {
   return (filtered_input_event_mask_ & PP_INPUTEVENT_CLASS_IME) ||
-      (input_event_mask_ & PP_INPUTEVENT_CLASS_IME);
+         (input_event_mask_ & PP_INPUTEVENT_CLASS_IME);
 }
 
 gfx::Rect PepperPluginInstanceImpl::GetCaretBounds() const {
   if (!text_input_caret_set_) {
     // If it is never set by the plugin, use the bottom left corner.
     return gfx::Rect(view_data_.rect.point.x,
                      view_data_.rect.point.y + view_data_.rect.size.height,
-                     0, 0);
+                     0,
+                     0);
   }
 
   // TODO(kinaba) Take CSS transformation into accont.
   // TODO(kinaba) Take bounding_box into account. On some platforms, an
   // "exclude rectangle" where candidate window must avoid the region can be
   // passed to IME. Currently, we pass only the caret rectangle because
   // it is the only information supported uniformly in Chromium.
   gfx::Rect caret(text_input_caret_);
   caret.Offset(view_data_.rect.point.x, view_data_.rect.point.y);
   return caret;
@@ skipping 23 matching lines @@
 
   bool rv = false;
   if (LoadInputEventInterface()) {
     PP_InputEvent_Class event_class = ClassifyInputEvent(event.type);
     if (!event_class)
       return false;
 
     if ((filtered_input_event_mask_ & event_class) ||
         (input_event_mask_ & event_class)) {
       // Actually send the event.
-      std::vector< ppapi::InputEventData > events;
+      std::vector<ppapi::InputEventData> events;
       CreateInputEventData(event, &events);
 
       // Allow the user gesture to be pending after the plugin handles the
       // event. This allows out-of-process plugins to respond to the user
       // gesture after processing has finished here.
       if (WebUserGestureIndicator::isProcessingUserGesture()) {
         pending_user_gesture_ =
             ppapi::EventTimeToPPTimeTicks(event.timeStampSeconds);
         pending_user_gesture_token_ =
             WebUserGestureIndicator::currentUserGestureToken();
         pending_user_gesture_token_.setOutOfProcess();
       }
 
       // Each input event may generate more than one PP_InputEvent.
       for (size_t i = 0; i < events.size(); i++) {
         if (filtered_input_event_mask_ & event_class)
           events[i].is_filtered = true;
         else
           rv = true;  // Unfiltered events are assumed to be handled.
         scoped_refptr<PPB_InputEvent_Shared> event_resource(
-            new PPB_InputEvent_Shared(ppapi::OBJECT_IS_IMPL,
-                                      pp_instance(), events[i]));
+            new PPB_InputEvent_Shared(
+                ppapi::OBJECT_IS_IMPL, pp_instance(), events[i]));
 
         rv |= PP_ToBool(plugin_input_event_interface_->HandleInputEvent(
             pp_instance(), event_resource->pp_resource()));
       }
     }
   }
 
   if (cursor_)
     *cursor_info = *cursor_;
   return rv;
@@ skipping 29 matching lines @@
   // in the "everything is clipped" case.
   gfx::Rect new_clip;
   if (!clip.IsEmpty())
     new_clip = clip;
 
   cut_outs_rects_ = cut_outs_rects;
 
   view_data_.rect = PP_FromGfxRect(position);
   view_data_.clip_rect = PP_FromGfxRect(clip);
   view_data_.device_scale = container_->deviceScaleFactor();
-  view_data_.css_scale = container_->pageZoomFactor() *
-                         container_->pageScaleFactor();
+  view_data_.css_scale =
+      container_->pageZoomFactor() * container_->pageScaleFactor();
 
   if (desired_fullscreen_state_ || view_data_.is_fullscreen) {
     WebElement element = container_->element();
     WebDocument document = element.document();
     bool is_fullscreen_element = (element == document.fullScreenElement());
     if (!view_data_.is_fullscreen && desired_fullscreen_state_ &&
         render_frame()->GetRenderWidget()->is_fullscreen() &&
         is_fullscreen_element) {
       // Entered fullscreen. Only possible via SetFullscreen().
       view_data_.is_fullscreen = true;
@@ skipping 108 matching lines @@
 
   gfx::Rect clip_page = PP_ToGfxRect(view_data_.clip_rect);
   gfx::Rect plugin_paint_rect =
       gfx::IntersectRects(plugin_backing_store_rect, clip_page);
   if (!plugin_paint_rect.Contains(relative_paint_bounds))
     return false;
 
   // Don't do optimized painting if the area to paint intersects with the
   // cut-out rects, otherwise we will paint over them.
   for (std::vector<gfx::Rect>::const_iterator iter = cut_outs_rects_.begin();
-       iter != cut_outs_rects_.end(); ++iter) {
+       iter != cut_outs_rects_.end();
+       ++iter) {
     if (relative_paint_bounds.Intersects(*iter))
       return false;
   }
 
   *dib = image_data->GetTransportDIB();
   plugin_backing_store_rect.Offset(plugin_offset);
   *location = plugin_backing_store_rect;
   clip_page.Offset(plugin_offset);
   *clip = clip_page;
   // The plugin scale factor is inverted, e.g. for a device scale factor of 2x
@@ skipping 76 matching lines @@
 
 bool PepperPluginInstanceImpl::StartFind(const base::string16& search_text,
                                          bool case_sensitive,
                                          int identifier) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PepperPluginInstanceImpl> ref(this);
   if (!LoadFindInterface())
     return false;
   find_identifier_ = identifier;
   return PP_ToBool(
-      plugin_find_interface_->StartFind(
-          pp_instance(),
-          base::UTF16ToUTF8(search_text).c_str(),
-          PP_FromBool(case_sensitive)));
+      plugin_find_interface_->StartFind(pp_instance(),
+                                        base::UTF16ToUTF8(search_text).c_str(),
+                                        PP_FromBool(case_sensitive)));
 }
 
 void PepperPluginInstanceImpl::SelectFindResult(bool forward) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PepperPluginInstanceImpl> ref(this);
   if (LoadFindInterface())
     plugin_find_interface_->SelectFindResult(pp_instance(),
                                              PP_FromBool(forward));
 }
 
 void PepperPluginInstanceImpl::StopFind() {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PepperPluginInstanceImpl> ref(this);
   if (!LoadFindInterface())
     return;
   find_identifier_ = -1;
   plugin_find_interface_->StopFind(pp_instance());
 }
 
 bool PepperPluginInstanceImpl::LoadFindInterface() {
   if (!module_->permissions().HasPermission(ppapi::PERMISSION_PRIVATE))
     return false;
   if (!plugin_find_interface_) {
-    plugin_find_interface_ =
-        static_cast<const PPP_Find_Private*>(module_->GetPluginInterface(
-            PPP_FIND_PRIVATE_INTERFACE));
+    plugin_find_interface_ = static_cast<const PPP_Find_Private*>(
+        module_->GetPluginInterface(PPP_FIND_PRIVATE_INTERFACE));
   }
 
   return !!plugin_find_interface_;
 }
 
 bool PepperPluginInstanceImpl::LoadInputEventInterface() {
   if (!checked_for_plugin_input_event_interface_) {
     checked_for_plugin_input_event_interface_ = true;
-    plugin_input_event_interface_ =
-        static_cast<const PPP_InputEvent*>(module_->GetPluginInterface(
-            PPP_INPUT_EVENT_INTERFACE));
+    plugin_input_event_interface_ = static_cast<const PPP_InputEvent*>(
+        module_->GetPluginInterface(PPP_INPUT_EVENT_INTERFACE));
   }
   return !!plugin_input_event_interface_;
 }
 
 bool PepperPluginInstanceImpl::LoadMessagingInterface() {
   if (!checked_for_plugin_messaging_interface_) {
     checked_for_plugin_messaging_interface_ = true;
-    plugin_messaging_interface_ =
-        static_cast<const PPP_Messaging*>(module_->GetPluginInterface(
-            PPP_MESSAGING_INTERFACE));
+    plugin_messaging_interface_ = static_cast<const PPP_Messaging*>(
+        module_->GetPluginInterface(PPP_MESSAGING_INTERFACE));
   }
   return !!plugin_messaging_interface_;
 }
 
 bool PepperPluginInstanceImpl::LoadMouseLockInterface() {
   if (!plugin_mouse_lock_interface_) {
-    plugin_mouse_lock_interface_ =
-        static_cast<const PPP_MouseLock*>(module_->GetPluginInterface(
-            PPP_MOUSELOCK_INTERFACE));
+    plugin_mouse_lock_interface_ = static_cast<const PPP_MouseLock*>(
+        module_->GetPluginInterface(PPP_MOUSELOCK_INTERFACE));
   }
 
   return !!plugin_mouse_lock_interface_;
 }
 
 bool PepperPluginInstanceImpl::LoadPdfInterface() {
   if (!checked_for_plugin_pdf_interface_) {
     checked_for_plugin_pdf_interface_ = true;
-    plugin_pdf_interface_ =
-        static_cast<const PPP_Pdf_1*>(module_->GetPluginInterface(
-            PPP_PDF_INTERFACE_1));
+    plugin_pdf_interface_ = static_cast<const PPP_Pdf_1*>(
+        module_->GetPluginInterface(PPP_PDF_INTERFACE_1));
   }
 
   return !!plugin_pdf_interface_;
 }
 
 bool PepperPluginInstanceImpl::LoadPrintInterface() {
   // Only check for the interface if the plugin has dev permission.
   if (!module_->permissions().HasPermission(ppapi::PERMISSION_DEV))
     return false;
   if (!plugin_print_interface_) {
     plugin_print_interface_ = static_cast<const PPP_Printing_Dev*>(
         module_->GetPluginInterface(PPP_PRINTING_DEV_INTERFACE));
   }
   return !!plugin_print_interface_;
 }
 
 bool PepperPluginInstanceImpl::LoadPrivateInterface() {
   // If this is a NaCl app, we want to talk to the trusted NaCl plugin to
   // call GetInstanceObject. This is necessary to ensure that the properties
   // the trusted plugin exposes (readyState and lastError) work properly. Note
   // that untrusted NaCl apps are not allowed to provide PPP_InstancePrivate,
   // so it's correct to never look up PPP_InstancePrivate for them.
   //
   // If this is *not* a NaCl plugin, original_module_ will never be set; we talk
   // to the "real" module.
-  scoped_refptr<PluginModule> module = original_module_ ? original_module_ :
-                                                          module_;
+  scoped_refptr<PluginModule> module =
+      original_module_ ? original_module_ : module_;
   // Only check for the interface if the plugin has private permission.
   if (!module->permissions().HasPermission(ppapi::PERMISSION_PRIVATE))
     return false;
   if (!plugin_private_interface_) {
     plugin_private_interface_ = static_cast<const PPP_Instance_Private*>(
         module->GetPluginInterface(PPP_INSTANCE_PRIVATE_INTERFACE));
   }
 
   return !!plugin_private_interface_;
 }
 
 bool PepperPluginInstanceImpl::LoadSelectionInterface() {
   if (!plugin_selection_interface_) {
-    plugin_selection_interface_ =
-        static_cast<const PPP_Selection_Dev*>(module_->GetPluginInterface(
-            PPP_SELECTION_DEV_INTERFACE));
+    plugin_selection_interface_ = static_cast<const PPP_Selection_Dev*>(
+        module_->GetPluginInterface(PPP_SELECTION_DEV_INTERFACE));
   }
   return !!plugin_selection_interface_;
 }
 
 bool PepperPluginInstanceImpl::LoadTextInputInterface() {
   if (!plugin_textinput_interface_) {
-    plugin_textinput_interface_ =
-        static_cast<const PPP_TextInput_Dev*>(module_->GetPluginInterface(
-            PPP_TEXTINPUT_DEV_INTERFACE));
+    plugin_textinput_interface_ = static_cast<const PPP_TextInput_Dev*>(
+        module_->GetPluginInterface(PPP_TEXTINPUT_DEV_INTERFACE));
   }
 
   return !!plugin_textinput_interface_;
 }
 
 bool PepperPluginInstanceImpl::LoadZoomInterface() {
   if (!plugin_zoom_interface_) {
-    plugin_zoom_interface_ =
-        static_cast<const PPP_Zoom_Dev*>(module_->GetPluginInterface(
-            PPP_ZOOM_DEV_INTERFACE));
+    plugin_zoom_interface_ = static_cast<const PPP_Zoom_Dev*>(
+        module_->GetPluginInterface(PPP_ZOOM_DEV_INTERFACE));
   }
 
   return !!plugin_zoom_interface_;
 }
 
 void PepperPluginInstanceImpl::UpdateLayerTransform() {
   if (!bound_graphics_2d_platform_ || !texture_layer_) {
     // Currently the transform is only applied for Graphics2D.
     return;
   }
@@ skipping 34 matching lines @@
 
   // instance_interface_ may have been cleared in Delete() if the
   // PepperWebPluginImpl is destroyed.
   if (instance_interface_)
     instance_interface_->DidChangeFocus(pp_instance(), PP_FromBool(has_focus));
 }
 
 void PepperPluginInstanceImpl::UpdateTouchEventRequest() {
   bool raw_touch = (filtered_input_event_mask_ & PP_INPUTEVENT_CLASS_TOUCH) ||
                    (input_event_mask_ & PP_INPUTEVENT_CLASS_TOUCH);
-  container_->requestTouchEventType(raw_touch ?
-      blink::WebPluginContainer::TouchEventRequestTypeRaw :
-      blink::WebPluginContainer::TouchEventRequestTypeSynthesizedMouse);
+  container_->requestTouchEventType(
+      raw_touch
+          ? blink::WebPluginContainer::TouchEventRequestTypeRaw
+          : blink::WebPluginContainer::TouchEventRequestTypeSynthesizedMouse);
 }
 
 bool PepperPluginInstanceImpl::IsAcceptingWheelEvents() const {
   return (filtered_input_event_mask_ & PP_INPUTEVENT_CLASS_WHEEL) ||
-      (input_event_mask_ & PP_INPUTEVENT_CLASS_WHEEL);
+         (input_event_mask_ & PP_INPUTEVENT_CLASS_WHEEL);
 }
 
 void PepperPluginInstanceImpl::ScheduleAsyncDidChangeView() {
   if (view_change_weak_ptr_factory_.HasWeakPtrs())
     return;  // Already scheduled.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&PepperPluginInstanceImpl::SendAsyncDidChangeView,
                  view_change_weak_ptr_factory_.GetWeakPtr()));
 }
@@ skipping 15 matching lines @@
 
   if (view_change_weak_ptr_factory_.HasWeakPtrs() ||
       (sent_initial_did_change_view_ &&
        last_sent_view_data_.Equals(view_data_)))
     return;  // Nothing to update.
 
   sent_initial_did_change_view_ = true;
   last_sent_view_data_ = view_data_;
   ScopedPPResource resource(
       ScopedPPResource::PassRef(),
-      (new PPB_View_Shared(ppapi::OBJECT_IS_IMPL,
-                           pp_instance(), view_data_))->GetReference());
+      (new PPB_View_Shared(ppapi::OBJECT_IS_IMPL, pp_instance(), view_data_))
+          ->GetReference());
 
   UpdateLayerTransform();
 
   // It's possible that Delete() has been called but the renderer hasn't
   // released its reference to this object yet.
   if (instance_interface_) {
-    instance_interface_->DidChangeView(pp_instance(), resource,
-                                       &view_data_.rect,
-                                       &view_data_.clip_rect);
+    instance_interface_->DidChangeView(
+        pp_instance(), resource, &view_data_.rect, &view_data_.clip_rect);
   }
 }
 
 void PepperPluginInstanceImpl::ReportGeometry() {
   // If this call was delayed, we may have transitioned back to fullscreen in
   // the mean time, so only report the geometry if we are actually in normal
   // mode.
   if (container_ && !fullscreen_container_ && !flash_fullscreen_)
     container_->reportGeometry();
 }
@@ skipping 36 matching lines @@
     return 0;
   }
   int num_pages = 0;
   PP_PrintSettings_Dev print_settings;
   print_settings.printable_area = PP_FromGfxRect(print_params.printableArea);
   print_settings.content_area = PP_FromGfxRect(print_params.printContentArea);
   print_settings.paper_size = PP_FromGfxSize(print_params.paperSize);
   print_settings.dpi = print_params.printerDPI;
   print_settings.orientation = PP_PRINTORIENTATION_NORMAL;
   print_settings.grayscale = PP_FALSE;
-  print_settings.print_scaling_option = static_cast<PP_PrintScalingOption_Dev>(
-      print_params.printScalingOption);
+  print_settings.print_scaling_option =
+      static_cast<PP_PrintScalingOption_Dev>(print_params.printScalingOption);
   print_settings.format = format;
-  num_pages = plugin_print_interface_->Begin(pp_instance(),
-                                             &print_settings);
+  num_pages = plugin_print_interface_->Begin(pp_instance(), &print_settings);
   if (!num_pages)
     return 0;
   current_print_settings_ = print_settings;
   canvas_.clear();
   ranges_.clear();
   return num_pages;
 }
 
 bool PepperPluginInstanceImpl::PrintPage(int page_number,
                                          blink::WebCanvas* canvas) {
@@ skipping 66 matching lines @@
   if (!LoadPdfInterface())
     return false;
 
   return true;
 }
 
 void PepperPluginInstanceImpl::RotateView(WebPlugin::RotationType type) {
   if (!LoadPdfInterface())
     return;
   PP_PrivatePageTransformType transform_type =
-      type == WebPlugin::RotationType90Clockwise ?
-      PP_PRIVATEPAGETRANSFORMTYPE_ROTATE_90_CW :
-      PP_PRIVATEPAGETRANSFORMTYPE_ROTATE_90_CCW;
+      type == WebPlugin::RotationType90Clockwise
+          ? PP_PRIVATEPAGETRANSFORMTYPE_ROTATE_90_CW
+          : PP_PRIVATEPAGETRANSFORMTYPE_ROTATE_90_CCW;
   plugin_pdf_interface_->Transform(pp_instance(), transform_type);
   // NOTE: plugin instance may have been deleted.
 }
 
 bool PepperPluginInstanceImpl::FlashIsFullscreenOrPending() {
   return fullscreen_container_ != NULL;
 }
 
 bool PepperPluginInstanceImpl::IsFullscreenOrPending() {
   return desired_fullscreen_state_;
 }
 
 bool PepperPluginInstanceImpl::SetFullscreen(bool fullscreen) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PepperPluginInstanceImpl> ref(this);
 
   // Check whether we are trying to switch to the state we're already going
   // to (i.e. if we're already switching to fullscreen but the fullscreen
   // container isn't ready yet, don't do anything more).
   if (fullscreen == IsFullscreenOrPending())
     return false;
 
   if (!render_frame_)
     return false;
-  if (fullscreen &&
-      !render_frame_->render_view()->renderer_preferences().
-          plugin_fullscreen_allowed)
+  if (fullscreen && !render_frame_->render_view()
+                         ->renderer_preferences()
+                         .plugin_fullscreen_allowed)
     return false;
 
   // Check whether we are trying to switch while the state is in transition.
   // The 2nd request gets dropped while messing up the internal state, so
   // disallow this.
   if (view_data_.is_fullscreen != desired_fullscreen_state_)
     return false;
 
   if (fullscreen && !IsProcessingUserGesture())
     return false;
@@ skipping 73 matching lines @@
   BufferAutoMapper mapper(enter.object());
   if (!mapper.data() || !mapper.size()) {
     NOTREACHED();
     return false;
   }
 #if defined(OS_WIN)
   // For Windows, we need the PDF DLL to render the output PDF to a DC.
   HMODULE pdf_module = GetModuleHandle(L"pdf.dll");
   if (!pdf_module)
     return false;
-  RenderPDFPageToDCProc render_proc =
-      reinterpret_cast<RenderPDFPageToDCProc>(
-          GetProcAddress(pdf_module, "RenderPDFPageToDC"));
+  RenderPDFPageToDCProc render_proc = reinterpret_cast<RenderPDFPageToDCProc>(
+      GetProcAddress(pdf_module, "RenderPDFPageToDC"));
   if (!render_proc)
     return false;
 #endif  // defined(OS_WIN)
 
   bool ret = false;
 #if defined(OS_POSIX) && !defined(OS_ANDROID)
   // On Linux we just set the final bits in the native metafile
   // (NativeMetafile and PreviewMetafile must have compatible formats,
   // i.e. both PDF for this to work).
   printing::Metafile* metafile =
       printing::MetafileSkiaWrapper::GetMetafileFromCanvas(*canvas);
   DCHECK(metafile != NULL);
   if (metafile)
     ret = metafile->InitFromData(mapper.data(), mapper.size());
 #elif defined(OS_WIN)
   printing::Metafile* metafile =
-    printing::MetafileSkiaWrapper::GetMetafileFromCanvas(*canvas);
+      printing::MetafileSkiaWrapper::GetMetafileFromCanvas(*canvas);
   if (metafile) {
     // We only have a metafile when doing print preview, so we just want to
     // pass the PDF off to preview.
     ret = metafile->InitFromData(mapper.data(), mapper.size());
   } else {
     // On Windows, we now need to render the PDF to the DC that backs the
     // supplied canvas.
     HDC dc = skia::BeginPlatformPaint(canvas);
     DrawEmptyRectangle(dc);
     gfx::Size size_in_pixels;
-    size_in_pixels.set_width(printing::ConvertUnit(
-        current_print_settings_.printable_area.size.width,
-        static_cast<int>(printing::kPointsPerInch),
-        current_print_settings_.dpi));
+    size_in_pixels.set_width(
+        printing::ConvertUnit(current_print_settings_.printable_area.size.width,
+                              static_cast<int>(printing::kPointsPerInch),
+                              current_print_settings_.dpi));
     size_in_pixels.set_height(printing::ConvertUnit(
         current_print_settings_.printable_area.size.height,
         static_cast<int>(printing::kPointsPerInch),
         current_print_settings_.dpi));
     // We need to scale down DC to fit an entire page into DC available area.
     // First, we'll try to use default scaling based on the 72dpi that is
     // used in webkit for printing.
     // If default scaling is not enough to fit the entire PDF without
     // Current metafile is based on screen DC and have current screen size.
     // Writing outside of those boundaries will result in the cut-off output.
     // On metafiles (this is the case here), scaling down will still record
     // original coordinates and we'll be able to print in full resolution.
     // Before playback we'll need to counter the scaling up that will happen
     // in the browser (printed_document_win.cc).
-    double dynamic_scale = gfx::CalculatePageScale(dc, size_in_pixels.width(),
-                                                   size_in_pixels.height());
+    double dynamic_scale = gfx::CalculatePageScale(
+        dc, size_in_pixels.width(), size_in_pixels.height());
     double page_scale = static_cast<double>(printing::kPointsPerInch) /
-        static_cast<double>(current_print_settings_.dpi);
+                        static_cast<double>(current_print_settings_.dpi);
 
     if (dynamic_scale < page_scale) {
       page_scale = dynamic_scale;
       printing::MetafileSkiaWrapper::SetCustomScaleOnCanvas(*canvas,
                                                             page_scale);
     }
 
     gfx::ScaleDC(dc, page_scale);
 
-    ret = render_proc(static_cast<unsigned char*>(mapper.data()), mapper.size(),
-                      0, dc, current_print_settings_.dpi,
-                      current_print_settings_.dpi, 0, 0, size_in_pixels.width(),
-                      size_in_pixels.height(), true, false, true, true, true);
+    ret = render_proc(static_cast<unsigned char*>(mapper.data()),
+                      mapper.size(),
+                      0,
+                      dc,
+                      current_print_settings_.dpi,
+                      current_print_settings_.dpi,
+                      0,
+                      0,
+                      size_in_pixels.width(),
+                      size_in_pixels.height(),
+                      true,
+                      false,
+                      true,
+                      true,
+                      true);
     skia::EndPlatformPaint(canvas);
   }
 #endif  // defined(OS_WIN)
 
   return ret;
 #else  // defined(ENABLE_FULL_PRINTING)
   return false;
 #endif
 }
 
@@ skipping 54 matching lines @@
     } else {
       container_->setWebLayer(web_layer_.get());
       texture_layer_->SetContentsOpaque(opaque);
     }
   }
   layer_bound_to_fullscreen_ = !!fullscreen_container_;
   layer_is_hardware_ = want_3d_layer;
   UpdateLayerTransform();
 }
 
-unsigned PepperPluginInstanceImpl::PrepareTexture() {
-  return 0;
-}
+unsigned PepperPluginInstanceImpl::PrepareTexture() { return 0; }
 
 bool PepperPluginInstanceImpl::PrepareTextureMailbox(
     cc::TextureMailbox* mailbox,
     scoped_ptr<cc::SingleReleaseCallback>* release_callback,
     bool use_shared_memory) {
   if (!bound_graphics_2d_platform_)
     return false;
-  return bound_graphics_2d_platform_->PrepareTextureMailbox(
-      mailbox, release_callback);
+  return bound_graphics_2d_platform_->PrepareTextureMailbox(mailbox,
+                                                            release_callback);
 }
 
-void PepperPluginInstanceImpl::OnDestruct() {
-  render_frame_ = NULL;
-}
+void PepperPluginInstanceImpl::OnDestruct() { render_frame_ = NULL; }
 
 void PepperPluginInstanceImpl::AddPluginObject(PluginObject* plugin_object) {
   DCHECK(live_plugin_objects_.find(plugin_object) ==
          live_plugin_objects_.end());
   live_plugin_objects_.insert(plugin_object);
 }
 
 void PepperPluginInstanceImpl::RemovePluginObject(PluginObject* plugin_object) {
   // Don't actually verify that the object is in the set since during module
   // deletion we'll be in the process of freeing them.
@@ skipping 42 matching lines @@
   bool handled = SimulateIMEEvent(input_event);
   if (handled)
     return;
 
   std::vector<linked_ptr<WebInputEvent> > events =
       CreateSimulatedWebInputEvents(
           input_event,
           view_data_.rect.point.x + view_data_.rect.size.width / 2,
           view_data_.rect.point.y + view_data_.rect.size.height / 2);
   for (std::vector<linked_ptr<WebInputEvent> >::iterator it = events.begin();
-      it != events.end(); ++it) {
+       it != events.end();
+       ++it) {
     web_view->handleInputEvent(*it->get());
   }
 }
 
 bool PepperPluginInstanceImpl::SimulateIMEEvent(
     const InputEventData& input_event) {
   switch (input_event.event_type) {
     case PP_INPUTEVENT_TYPE_IME_COMPOSITION_START:
     case PP_INPUTEVENT_TYPE_IME_COMPOSITION_UPDATE:
       SimulateImeSetCompositionEvent(input_event);
@@ skipping 37 matching lines @@
     if (input_event.composition_target_segment == static_cast<int32_t>(i - 2))
       underline.thick = true;
     underlines.push_back(underline);
   }
 
   render_frame_->SimulateImeSetComposition(
       utf16_text, underlines, offsets[0], offsets[1]);
 }
 
 ContentDecryptorDelegate*
-    PepperPluginInstanceImpl::GetContentDecryptorDelegate() {
+PepperPluginInstanceImpl::GetContentDecryptorDelegate() {
   if (content_decryptor_delegate_)
     return content_decryptor_delegate_.get();
 
   const PPP_ContentDecryptor_Private* plugin_decryption_interface =
       static_cast<const PPP_ContentDecryptor_Private*>(
-          module_->GetPluginInterface(
-              PPP_CONTENTDECRYPTOR_PRIVATE_INTERFACE));
+          module_->GetPluginInterface(PPP_CONTENTDECRYPTOR_PRIVATE_INTERFACE));
   if (!plugin_decryption_interface)
     return NULL;
 
   content_decryptor_delegate_.reset(
       new ContentDecryptorDelegate(pp_instance_, plugin_decryption_interface));
   return content_decryptor_delegate_.get();
 }
 
 PP_Bool PepperPluginInstanceImpl::BindGraphics(PP_Instance instance,
                                                PP_Resource device) {
@@ skipping 27 matching lines @@
       RendererPpapiHost::GetForPPInstance(instance)->GetPpapiHost();
   ppapi::host::ResourceHost* host = ppapi_host->GetResourceHost(device);
   PepperGraphics2DHost* graphics_2d = NULL;
   if (host) {
     if (host->IsGraphics2DHost())
       graphics_2d = static_cast<PepperGraphics2DHost*>(host);
     DLOG_IF(ERROR, !graphics_2d) << "Resource is not PepperGraphics2DHost.";
   }
 
   EnterResourceNoLock<PPB_Graphics3D_API> enter_3d(device, false);
-  PPB_Graphics3D_Impl* graphics_3d = enter_3d.succeeded() ?
-      static_cast<PPB_Graphics3D_Impl*>(enter_3d.object()) : NULL;
+  PPB_Graphics3D_Impl* graphics_3d =
+      enter_3d.succeeded()
+          ? static_cast<PPB_Graphics3D_Impl*>(enter_3d.object())
+          : NULL;
 
   if (graphics_2d) {
     if (graphics_2d->BindToInstance(this)) {
       bound_graphics_2d_platform_ = graphics_2d;
       UpdateLayer();
       return PP_TRUE;
     }
   } else if (graphics_3d) {
     // Make sure graphics can only be bound to the instance it is
     // associated with.
@@ skipping 63 matching lines @@
   WebFrame* frame = container_->element().document().frame();
   if (!frame) {
     try_catch.SetException("No frame to execute script in.");
     return PP_MakeUndefined();
   }
 
   NPVariant result;
   bool ok = false;
   if (IsProcessingUserGesture()) {
     blink::WebScopedUserGesture user_gesture(CurrentUserGestureToken());
-    ok = WebBindings::evaluate(NULL, frame->windowObject(), &np_script,
-                               &result);
+    ok =
+        WebBindings::evaluate(NULL, frame->windowObject(), &np_script, &result);
   } else {
-    ok = WebBindings::evaluate(NULL, frame->windowObject(), &np_script,
-                               &result);
+    ok =
+        WebBindings::evaluate(NULL, frame->windowObject(), &np_script, &result);
   }
   if (!ok) {
     // TryCatch doesn't catch the exceptions properly. Since this is only for
     // a trusted API, just set to a general exception message.
     try_catch.SetException("Exception caught");
     WebBindings::releaseVariantValue(&result);
     return PP_MakeUndefined();
   }
 
   PP_Var ret = NPVariantToPPVar(this, &result);
@@ skipping 80 matching lines @@
                                                        request_id);
 }
 
 void PepperPluginInstanceImpl::DecoderResetDone(
     PP_Instance instance,
     PP_DecryptorStreamType decoder_type,
     uint32_t request_id) {
   content_decryptor_delegate_->DecoderResetDone(decoder_type, request_id);
 }
 
-
 void PepperPluginInstanceImpl::DeliverFrame(
     PP_Instance instance,
     PP_Resource decrypted_frame,
     const PP_DecryptedFrameInfo* frame_info) {
   content_decryptor_delegate_->DeliverFrame(decrypted_frame, frame_info);
 }
 
 void PepperPluginInstanceImpl::DeliverSamples(
     PP_Instance instance,
     PP_Resource audio_frames,
     const PP_DecryptedSampleInfo* sample_info) {
   content_decryptor_delegate_->DeliverSamples(audio_frames, sample_info);
 }
 
 void PepperPluginInstanceImpl::SetPluginToHandleFindRequests(
     PP_Instance instance) {
   if (!LoadFindInterface())
     return;
-  bool is_main_frame = render_frame_ &&
+  bool is_main_frame =
+      render_frame_ &&
       render_frame_->GetRenderView()->GetMainRenderFrame() == render_frame_;
   if (!is_main_frame)
     return;
   render_frame_->render_view()->set_plugin_find_handler(this);
 }
 
 void PepperPluginInstanceImpl::NumberOfFindResultsChanged(
     PP_Instance instance,
     int32_t total,
     PP_Bool final_result) {
@@ skipping 18 matching lines @@
                                             uint32_t count) {
   if (!render_frame_ || !render_frame_->GetWebFrame())
     return;
 
   blink::WebVector<blink::WebRect> tickmarks_converted(
       static_cast<size_t>(count));
   for (uint32 i = 0; i < count; ++i) {
     tickmarks_converted[i] = blink::WebRect(tickmarks[i].point.x,
                                             tickmarks[i].point.y,
                                             tickmarks[i].size.width,
-                                            tickmarks[i].size.height);;
+                                            tickmarks[i].size.height);
+    ;
   }
   blink::WebFrame* frame = render_frame_->GetWebFrame();
   frame->setTickmarks(tickmarks_converted);
 }
 
 PP_Bool PepperPluginInstanceImpl::IsFullscreen(PP_Instance instance) {
   return PP_FromBool(view_data_.is_fullscreen);
 }
 
 PP_Bool PepperPluginInstanceImpl::SetFullscreen(PP_Instance instance,
@@ skipping 83 matching lines @@
                                                  double minimum_factor,
                                                  double maximum_factor) {
   if (!render_frame_)
     return;
   if (minimum_factor > maximum_factor) {
     NOTREACHED();
     return;
   }
   double minimum_level = ZoomFactorToZoomLevel(minimum_factor);
   double maximum_level = ZoomFactorToZoomLevel(maximum_factor);
-  render_frame_->render_view()->webview()->zoomLimitsChanged(
-      minimum_level, maximum_level);
+  render_frame_->render_view()->webview()->zoomLimitsChanged(minimum_level,
+                                                             maximum_level);
 }
 
 void PepperPluginInstanceImpl::PostMessage(PP_Instance instance,
                                            PP_Var message) {
   message_channel_->PostMessageToJavaScript(message);
 }
 
 PP_Bool PepperPluginInstanceImpl::SetCursor(PP_Instance instance,
                                             PP_MouseCursor_Type type,
                                             PP_Resource image,
@@ skipping 126 matching lines @@
     PP_Instance instance,
     PP_Var relative,
     PP_URLComponents_Dev* components) {
   StringVar* relative_string = StringVar::FromPPVar(relative);
   if (!relative_string)
     return PP_MakeNull();
 
   WebElement plugin_element = container()->element();
   GURL document_url = plugin_element.document().baseURL();
   return ppapi::PPB_URLUtil_Shared::GenerateURLReturn(
-      document_url.Resolve(relative_string->value()),
-      components);
+      document_url.Resolve(relative_string->value()), components);
 }
 
 PP_Bool PepperPluginInstanceImpl::DocumentCanRequest(PP_Instance instance,
                                                      PP_Var url) {
   StringVar* url_string = StringVar::FromPPVar(url);
   if (!url_string)
     return PP_FALSE;
 
   blink::WebSecurityOrigin security_origin;
   if (!SecurityOriginForInstance(instance, &security_origin))
@@ skipping 24 matching lines @@
     PP_Instance instance,
     PP_URLComponents_Dev* components) {
   blink::WebDocument document = container()->element().document();
   return ppapi::PPB_URLUtil_Shared::GenerateURLReturn(document.url(),
                                                       components);
 }
 
 PP_Var PepperPluginInstanceImpl::GetPluginInstanceURL(
     PP_Instance instance,
     PP_URLComponents_Dev* components) {
-  return ppapi::PPB_URLUtil_Shared::GenerateURLReturn(plugin_url_,
-                                                      components);
+  return ppapi::PPB_URLUtil_Shared::GenerateURLReturn(plugin_url_, components);
 }
 
 PP_Var PepperPluginInstanceImpl::GetPluginReferrerURL(
     PP_Instance instance,
     PP_URLComponents_Dev* components) {
   blink::WebDocument document = container()->element().document();
   if (!full_frame_)
     return ppapi::PPB_URLUtil_Shared::GenerateURLReturn(document.url(),
                                                         components);
   WebFrame* frame = document.frame();
@@ skipping 42 matching lines @@
   checked_for_plugin_messaging_interface_ = false;
   plugin_mouse_lock_interface_ = NULL;
   plugin_pdf_interface_ = NULL;
   checked_for_plugin_pdf_interface_ = false;
   plugin_private_interface_ = NULL;
   plugin_selection_interface_ = NULL;
   plugin_textinput_interface_ = NULL;
   plugin_zoom_interface_ = NULL;
 
   // Re-send the DidCreate event via the proxy.
-  scoped_ptr<const char*[]> argn_array(StringVectorToArgArray(argn_));
-  scoped_ptr<const char*[]> argv_array(StringVectorToArgArray(argv_));
-  if (!instance_interface_->DidCreate(pp_instance(), argn_.size(),
-                                      argn_array.get(), argv_array.get()))
+  scoped_ptr<const char * []> argn_array(StringVectorToArgArray(argn_));
+  scoped_ptr<const char * []> argv_array(StringVectorToArgArray(argv_));

[bbudge, 2014/04/07 17:02:17]

This is kind of weird.

+  if (!instance_interface_->DidCreate(
+          pp_instance(), argn_.size(), argn_array.get(), argv_array.get()))
     return PP_EXTERNAL_PLUGIN_ERROR_INSTANCE;
   message_channel_->StopQueueingJavaScriptMessages();
 
   // Clear sent_initial_did_change_view_ and cancel any pending DidChangeView
   // event. This way, SendDidChangeView will send the "current" view
   // immediately (before other events like HandleDocumentLoad).
   sent_initial_did_change_view_ = false;
   view_change_weak_ptr_factory_.InvalidateWeakPtrs();
   SendDidChangeView();
 
   DCHECK(external_document_load_);
   external_document_load_ = false;
   if (!external_document_response_.isNull()) {
     document_loader_ = NULL;
     // Pass the response to the new proxy.
     HandleDocumentLoad(external_document_response_);
     external_document_response_ = blink::WebURLResponse();
     // Replay any document load events we've received to the real loader.
     external_document_loader_->ReplayReceivedData(document_loader_);
     external_document_loader_.reset(NULL);
   }
 
   return PP_EXTERNAL_PLUGIN_OK;
 }
 
 bool PepperPluginInstanceImpl::IsValidInstanceOf(PluginModule* module) {
   DCHECK(module);
-  return module == module_.get() ||
-         module == original_module_.get();
+  return module == module_.get() || module == original_module_.get();
 }
 
-NPP PepperPluginInstanceImpl::instanceNPP() {
-  return npp_.get();
-}
+NPP PepperPluginInstanceImpl::instanceNPP() { return npp_.get(); }
 
 PepperPluginInstance* PepperPluginInstance::Get(PP_Instance instance_id) {
   return HostGlobals::Get()->GetInstance(instance_id);
 }
 
 RenderView* PepperPluginInstanceImpl::GetRenderView() {
   return render_frame_ ? render_frame_->render_view() : NULL;
 }
 
 blink::WebPluginContainer* PepperPluginInstanceImpl::GetContainer() {
   return container_;
 }
 
-v8::Isolate* PepperPluginInstanceImpl::GetIsolate() const {
-  return isolate_;
-}
+v8::Isolate* PepperPluginInstanceImpl::GetIsolate() const { return isolate_; }
 
 ppapi::VarTracker* PepperPluginInstanceImpl::GetVarTracker() {
   return HostGlobals::Get()->GetVarTracker();
 }
 
-const GURL& PepperPluginInstanceImpl::GetPluginURL() {
-  return plugin_url_;
-}
+const GURL& PepperPluginInstanceImpl::GetPluginURL() { return plugin_url_; }
 
 base::FilePath PepperPluginInstanceImpl::GetModulePath() {
   return module_->path();
 }
 
 PP_Resource PepperPluginInstanceImpl::CreateImage(gfx::ImageSkia* source_image,
                                                   float scale) {
   gfx::ImageSkiaRep image_skia_rep = source_image->GetRepresentation(scale);
 
   if (image_skia_rep.is_null() || image_skia_rep.scale() != scale)
     return 0;
 
-  scoped_refptr<PPB_ImageData_Impl> image_data(new PPB_ImageData_Impl(
-      pp_instance(),
-      PPB_ImageData_Impl::PLATFORM));
-  if (!image_data->Init(
-          PPB_ImageData_Impl::GetNativeImageDataFormat(),
-          image_skia_rep.pixel_width(),
-          image_skia_rep.pixel_height(),
-          false)) {
+  scoped_refptr<PPB_ImageData_Impl> image_data(
+      new PPB_ImageData_Impl(pp_instance(), PPB_ImageData_Impl::PLATFORM));
+  if (!image_data->Init(PPB_ImageData_Impl::GetNativeImageDataFormat(),
+                        image_skia_rep.pixel_width(),
+                        image_skia_rep.pixel_height(),
+                        false)) {
     return 0;
   }
 
   ImageDataAutoMapper mapper(image_data.get());
   if (!mapper.is_valid())
     return 0;
 
   skia::PlatformCanvas* canvas = image_data->GetPlatformCanvas();
   // Note: Do not SkBitmap::copyTo the canvas bitmap directly because it will
   // ignore the allocated pixels in shared memory and re-allocate a new buffer.
   canvas->writePixels(image_skia_rep.sk_bitmap(), 0, 0);
 
   return image_data->GetReference();
 }
 
 PP_ExternalPluginResult PepperPluginInstanceImpl::SwitchToOutOfProcessProxy(
     const base::FilePath& file_path,
     ppapi::PpapiPermissions permissions,
     const IPC::ChannelHandle& channel_handle,
     base::ProcessId plugin_pid,
     int plugin_child_id) {
   // Create a new module for each instance of the external plugin that is using
   // the IPC based out-of-process proxy. We can't use the existing module,
   // because it is configured for the in-process plugin, and we must keep it
   // that way to allow the page to create other instances.
   scoped_refptr<PluginModule> external_plugin_module(
       module_->CreateModuleForExternalPluginInstance());
 
   RendererPpapiHostImpl* renderer_ppapi_host =
-      external_plugin_module->CreateOutOfProcessModule(
-          render_frame_,
-          file_path,
-          permissions,
-          channel_handle,
-          plugin_pid,
-          plugin_child_id,
-          true);
+      external_plugin_module->CreateOutOfProcessModule(render_frame_,
+                                                       file_path,
+                                                       permissions,
+                                                       channel_handle,
+                                                       plugin_pid,
+                                                       plugin_child_id,
+                                                       true);
   if (!renderer_ppapi_host) {
     DLOG(ERROR) << "CreateExternalPluginModule() failed";
     return PP_EXTERNAL_PLUGIN_ERROR_MODULE;
   }
 
   // Finally, switch the instance to the proxy.
   return external_plugin_module->InitAsProxiedExternalPlugin(this);
 }
 
 void PepperPluginInstanceImpl::SetAlwaysOnTop(bool on_top) {
@@ skipping 21 matching lines @@
   scoped_refptr<PepperPluginInstanceImpl> ref(this);
 
   // We check whether we are trying to switch to the state we're already going
   // to (i.e. if we're already switching to fullscreen but the fullscreen
   // container isn't ready yet, don't do anything more).
   if (fullscreen == FlashIsFullscreenOrPending())
     return true;
 
   if (!render_frame_)
     return false;
-  if (fullscreen &&
-      !render_frame_->render_view()->renderer_preferences().
-          plugin_fullscreen_allowed)
+  if (fullscreen && !render_frame_->render_view()
+                         ->renderer_preferences()
+                         .plugin_fullscreen_allowed)
     return false;
 
   // Unbind current 2D or 3D graphics context.
   VLOG(1) << "Setting fullscreen to " << (fullscreen ? "on" : "off");
   if (fullscreen) {
     DCHECK(!fullscreen_container_);
     fullscreen_container_ =
         render_frame_->CreatePepperFullscreenContainer(this);
     UpdateLayer();
   } else {
@@ skipping 28 matching lines @@
     return PP_ERROR_FAILED;
 
   WebDocument document = container_->element().document();
   WebFrame* frame = document.frame();
   if (!frame)
     return PP_ERROR_FAILED;
 
   ppapi::URLRequestInfoData completed_request = request;
 
   WebURLRequest web_request;
-  if (!CreateWebURLRequest(pp_instance_,
-                           &completed_request,
-                           frame,
-                           &web_request)) {
+  if (!CreateWebURLRequest(
+          pp_instance_, &completed_request, frame, &web_request)) {
     return PP_ERROR_FAILED;
   }
   web_request.setFirstPartyForCookies(document.firstPartyForCookies());
   web_request.setHasUserGesture(from_user_action);
 
   GURL gurl(web_request.url());
   if (gurl.SchemeIs("javascript")) {
     // In imitation of the NPAPI implementation, only |target_frame == frame| is
     // allowed for security reasons.
     WebFrame* target_frame =
         frame->view()->findFrameByName(WebString::fromUTF8(target), frame);
     if (target_frame != frame)
       return PP_ERROR_NOACCESS;
 
     // TODO(viettrungluu): NPAPI sends the result back to the plugin -- do we
     // need that?
     WebString result = container_->executeScriptURL(gurl, from_user_action);
     return result.isNull() ? PP_ERROR_FAILED : PP_OK;
   }
 
   // Only GETs and POSTs are supported.
-  if (web_request.httpMethod() != "GET" &&
-      web_request.httpMethod() != "POST")
+  if (web_request.httpMethod() != "GET" && web_request.httpMethod() != "POST")
     return PP_ERROR_BADARGUMENT;
 
   WebString target_str = WebString::fromUTF8(target);
   container_->loadFrameRequest(web_request, target_str, false, NULL);
   return PP_OK;
 }
 
 int PepperPluginInstanceImpl::MakePendingFileRefRendererHost(
     const base::FilePath& path) {
   RendererPpapiHostImpl* host_impl = module_->renderer_ppapi_host();
   PepperFileRefRendererHost* file_ref_host(
       new PepperFileRefRendererHost(host_impl, pp_instance(), 0, path));
   return host_impl->GetPpapiHost()->AddPendingResourceHost(
       scoped_ptr<ppapi::host::ResourceHost>(file_ref_host));
 }
 
-void PepperPluginInstanceImpl::SetEmbedProperty(PP_Var key,
-                                                PP_Var value) {
+void PepperPluginInstanceImpl::SetEmbedProperty(PP_Var key, PP_Var value) {
   message_channel_->SetReadOnlyProperty(key, value);
 }
 
 bool PepperPluginInstanceImpl::CanAccessMainFrame() const {
   if (!container_)
     return false;
   blink::WebDocument containing_document = container_->element().document();
 
-  if (!containing_document.frame() ||
-      !containing_document.frame()->view() ||
+  if (!containing_document.frame() || !containing_document.frame()->view() ||
       !containing_document.frame()->view()->mainFrame()) {
     return false;
   }
   blink::WebDocument main_document =
       containing_document.frame()->view()->mainFrame()->document();
 
   return containing_document.securityOrigin().canAccess(
       main_document.securityOrigin());
 }
 
@@ skipping 45 matching lines @@
 bool PepperPluginInstanceImpl::IsMouseLocked() {
   return GetMouseLockDispatcher()->IsMouseLockedTo(
       GetOrCreateLockTargetAdapter());
 }
 
 bool PepperPluginInstanceImpl::LockMouse() {
   return GetMouseLockDispatcher()->LockMouse(GetOrCreateLockTargetAdapter());
 }
 
 MouseLockDispatcher::LockTarget*
-    PepperPluginInstanceImpl::GetOrCreateLockTargetAdapter() {
+PepperPluginInstanceImpl::GetOrCreateLockTargetAdapter() {
   if (!lock_target_.get()) {
     lock_target_.reset(new PluginInstanceLockTarget(this));
   }
   return lock_target_.get();
 }
 
 MouseLockDispatcher* PepperPluginInstanceImpl::GetMouseLockDispatcher() {
   if (flash_fullscreen_) {
     RenderWidgetFullscreenPepper* container =
         static_cast<RenderWidgetFullscreenPepper*>(fullscreen_container_);
@@ skipping 16 matching lines @@
     int pending_host_id,
     const ppapi::URLResponseInfoData& data) {
   RendererPpapiHostImpl* host_impl = module_->renderer_ppapi_host();
 
   if (host_impl->in_process_router()) {
     // Running in-process, we can just create the resource and call the
     // PPP_Instance function directly.
     scoped_refptr<ppapi::proxy::URLLoaderResource> loader_resource(
         new ppapi::proxy::URLLoaderResource(
             host_impl->in_process_router()->GetPluginConnection(pp_instance()),
-            pp_instance(), pending_host_id, data));
+            pp_instance(),
+            pending_host_id,
+            data));
 
     PP_Resource loader_pp_resource = loader_resource->GetReference();
-    if (!instance_interface_->HandleDocumentLoad(
-            pp_instance(), loader_pp_resource))
+    if (!instance_interface_->HandleDocumentLoad(pp_instance(),
+                                                 loader_pp_resource))
       loader_resource->Close();
     // We don't pass a ref into the plugin, if it wants one, it will have taken
     // an additional one.
     ppapi::PpapiGlobals::Get()->GetResourceTracker()->ReleaseResource(
         loader_pp_resource);
   } else {
     // Running out-of-process. Initiate an IPC call to notify the plugin
     // process.
     ppapi::proxy::HostDispatcher* dispatcher =
         ppapi::proxy::HostDispatcher::GetForInstance(pp_instance());
     dispatcher->Send(new PpapiMsg_PPPInstance_HandleDocumentLoad(
         ppapi::API_ID_PPP_INSTANCE, pp_instance(), pending_host_id, data));
   }
 }
 
 }  // namespace content