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

content/renderer/pepper/pepper_plugin_instance_impl.h

 // 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.
 
 #ifndef CONTENT_RENDERER_PEPPER_PEPPER_PLUGIN_INSTANCE_IMPL_H_
 #define CONTENT_RENDERER_PEPPER_PEPPER_PLUGIN_INSTANCE_IMPL_H_
 
 #include <list>
 #include <set>
 #include <string>
@@ skipping 107 matching lines @@
     : public base::RefCounted<PepperPluginInstanceImpl>,
       public NON_EXPORTED_BASE(PepperPluginInstance),
       public ppapi::PPB_Instance_Shared,
       public NON_EXPORTED_BASE(cc::TextureLayerClient),
       public RenderFrameObserver {
  public:
   // Create and return a PepperPluginInstanceImpl object which supports the most
   // recent version of PPP_Instance possible by querying the given
   // get_plugin_interface function. If the plugin does not support any valid
   // PPP_Instance interface, returns NULL.
-  static PepperPluginInstanceImpl* Create(
-      RenderFrameImpl* render_frame,
-      PluginModule* module,
-      blink::WebPluginContainer* container,
-      const GURL& plugin_url);
+  static PepperPluginInstanceImpl* Create(RenderFrameImpl* render_frame,
+                                          PluginModule* module,
+                                          blink::WebPluginContainer* container,
+                                          const GURL& plugin_url);
   RenderFrameImpl* render_frame() const { return render_frame_; }
   PluginModule* module() const { return module_.get(); }
   MessageChannel& message_channel() { return *message_channel_; }
 
   blink::WebPluginContainer* container() const { return container_; }
 
   // Returns the PP_Instance uniquely identifying this instance. Guaranteed
   // nonzero.
   PP_Instance pp_instance() const { return pp_instance_; }
 
@@ skipping 38 matching lines @@
   const ppapi::ViewData& view_data() const { return view_data_; }
 
   // PPP_Instance and PPP_Instance_Private.
   bool Initialize(const std::vector<std::string>& arg_names,
                   const std::vector<std::string>& arg_values,
                   bool full_frame);
   bool HandleDocumentLoad(const blink::WebURLResponse& response);
   bool HandleInputEvent(const blink::WebInputEvent& event,
                         blink::WebCursorInfo* cursor_info);
   PP_Var GetInstanceObject();
-  void ViewChanged(const gfx::Rect& position, const gfx::Rect& clip,
+  void ViewChanged(const gfx::Rect& position,
+                   const gfx::Rect& clip,
                    const std::vector<gfx::Rect>& cut_outs_rects);
 
   // Handlers for composition events.
   bool HandleCompositionStart(const base::string16& text);
   bool HandleCompositionUpdate(
       const base::string16& text,
       const std::vector<blink::WebCompositionUnderline>& underlines,
       int selection_start,
       int selection_end);
   bool HandleCompositionEnd(const base::string16& text);
@@ skipping 112 matching lines @@
   // A mouse lock is enabled and mouse events are being delivered.
   void HandleMouseLockedInputEvent(const blink::WebMouseEvent& event);
 
   // Simulates an input event to the plugin by passing it down to WebKit,
   // which sends it back up to the plugin as if it came from the user.
   void SimulateInputEvent(const ppapi::InputEventData& input_event);
 
   // Simulates an IME event at the level of RenderView which sends it back up to
   // the plugin as if it came from the user.
   bool SimulateIMEEvent(const ppapi::InputEventData& input_event);
-  void SimulateImeSetCompositionEvent(
-      const ppapi::InputEventData& input_event);
+  void SimulateImeSetCompositionEvent(const ppapi::InputEventData& input_event);
 
   // The document loader is valid when the plugin is "full-frame" and in this
   // case is non-NULL as long as the corresponding loader resource is alive.
   // This pointer is non-owning, so the loader must use set_document_loader to
   // clear itself when it is destroyed.
   blink::WebURLLoaderClient* document_loader() const {
     return document_loader_;
   }
   void set_document_loader(blink::WebURLLoaderClient* loader) {
     document_loader_ = loader;
@@ skipping 16 matching lines @@
       const IPC::ChannelHandle& channel_handle,
       base::ProcessId plugin_pid,
       int plugin_child_id) OVERRIDE;
   virtual void SetAlwaysOnTop(bool on_top) OVERRIDE;
   virtual bool IsFullPagePlugin() OVERRIDE;
   virtual bool FlashSetFullscreen(bool fullscreen, bool delay_report) OVERRIDE;
   virtual bool IsRectTopmost(const gfx::Rect& rect) OVERRIDE;
   virtual int32_t Navigate(const ppapi::URLRequestInfoData& request,
                            const char* target,
                            bool from_user_action) OVERRIDE;
-  virtual int MakePendingFileRefRendererHost(
-      const base::FilePath& path) OVERRIDE;
+  virtual int MakePendingFileRefRendererHost(const base::FilePath& path)
+      OVERRIDE;
   virtual void SetEmbedProperty(PP_Var key, PP_Var value) OVERRIDE;
   virtual void SetSelectedText(const base::string16& selected_text) OVERRIDE;
   virtual void SetLinkUnderCursor(const std::string& url) OVERRIDE;
 
   // PPB_Instance_API implementation.
   virtual PP_Bool BindGraphics(PP_Instance instance,
                                PP_Resource device) OVERRIDE;
   virtual PP_Bool IsFullFrame(PP_Instance instance) OVERRIDE;
   virtual const ppapi::ViewData* GetViewData(PP_Instance instance) OVERRIDE;
   virtual PP_Bool FlashIsFullscreen(PP_Instance instance) OVERRIDE;
@@ skipping 12 matching lines @@
                                           int32_t total,
                                           PP_Bool final_result) OVERRIDE;
   virtual void SelectedFindResultChanged(PP_Instance instance,
                                          int32_t index) OVERRIDE;
   virtual void SetTickmarks(PP_Instance instance,
                             const PP_Rect* tickmarks,
                             uint32_t count) OVERRIDE;
   virtual PP_Bool IsFullscreen(PP_Instance instance) OVERRIDE;
   virtual PP_Bool SetFullscreen(PP_Instance instance,
                                 PP_Bool fullscreen) OVERRIDE;
-  virtual PP_Bool GetScreenSize(PP_Instance instance, PP_Size* size)
+  virtual PP_Bool GetScreenSize(PP_Instance instance, PP_Size* size) OVERRIDE;
+  virtual ppapi::Resource* GetSingletonResource(PP_Instance instance,
+                                                ppapi::SingletonResourceID id)
       OVERRIDE;
-  virtual ppapi::Resource* GetSingletonResource(PP_Instance instance,
-      ppapi::SingletonResourceID id) OVERRIDE;
   virtual int32_t RequestInputEvents(PP_Instance instance,
                                      uint32_t event_classes) OVERRIDE;
   virtual int32_t RequestFilteringInputEvents(PP_Instance instance,
                                               uint32_t event_classes) OVERRIDE;
   virtual void ClearInputEventRequest(PP_Instance instance,
                                       uint32_t event_classes) OVERRIDE;
   virtual void ZoomChanged(PP_Instance instance, double factor) OVERRIDE;
   virtual void ZoomLimitsChanged(PP_Instance instance,
                                  double minimum_factor,
                                  double maximum_factor) OVERRIDE;
   virtual void PostMessage(PP_Instance instance, PP_Var message) OVERRIDE;
   virtual PP_Bool SetCursor(PP_Instance instance,
                             PP_MouseCursor_Type type,
                             PP_Resource image,
                             const PP_Point* hot_spot) OVERRIDE;
-  virtual int32_t LockMouse(
-      PP_Instance instance,
-      scoped_refptr<ppapi::TrackedCallback> callback) OVERRIDE;
+  virtual int32_t LockMouse(PP_Instance instance,
+                            scoped_refptr<ppapi::TrackedCallback> callback)
+      OVERRIDE;
   virtual void UnlockMouse(PP_Instance instance) OVERRIDE;
   virtual void SetTextInputType(PP_Instance instance,
                                 PP_TextInput_Type type) OVERRIDE;
   virtual void UpdateCaretPosition(PP_Instance instance,
                                    const PP_Rect& caret,
                                    const PP_Rect& bounding_box) OVERRIDE;
   virtual void CancelCompositionText(PP_Instance instance) OVERRIDE;
   virtual void SelectionChanged(PP_Instance instance) OVERRIDE;
   virtual void UpdateSurroundingText(PP_Instance instance,
                                      const char* text,
                                      uint32_t caret,
                                      uint32_t anchor) OVERRIDE;
-  virtual PP_Var ResolveRelativeToDocument(
-      PP_Instance instance,
-      PP_Var relative,
-      PP_URLComponents_Dev* components) OVERRIDE;
+  virtual PP_Var ResolveRelativeToDocument(PP_Instance instance,
+                                           PP_Var relative,
+                                           PP_URLComponents_Dev* components)
+      OVERRIDE;
   virtual PP_Bool DocumentCanRequest(PP_Instance instance, PP_Var url) OVERRIDE;
   virtual PP_Bool DocumentCanAccessDocument(PP_Instance instance,
                                             PP_Instance target) OVERRIDE;
   virtual PP_Var GetDocumentURL(PP_Instance instance,
                                 PP_URLComponents_Dev* components) OVERRIDE;
-  virtual PP_Var GetPluginInstanceURL(
-      PP_Instance instance,
-      PP_URLComponents_Dev* components) OVERRIDE;
-  virtual PP_Var GetPluginReferrerURL(
-      PP_Instance instance,
-      PP_URLComponents_Dev* components) OVERRIDE;
+  virtual PP_Var GetPluginInstanceURL(PP_Instance instance,
+                                      PP_URLComponents_Dev* components)
+      OVERRIDE;
+  virtual PP_Var GetPluginReferrerURL(PP_Instance instance,
+                                      PP_URLComponents_Dev* components)
+      OVERRIDE;
 
   // PPB_ContentDecryptor_Private implementation.
   virtual void SessionCreated(PP_Instance instance,
                               uint32_t session_id,
                               PP_Var web_session_id_var) OVERRIDE;
   virtual void SessionMessage(PP_Instance instance,
                               uint32_t session_id,
                               PP_Var message,
                               PP_Var destination_url) OVERRIDE;
   virtual void SessionReady(PP_Instance instance, uint32_t session_id) OVERRIDE;
@@ skipping 12 matching lines @@
                                      PP_Bool success) OVERRIDE;
   virtual void DecoderDeinitializeDone(PP_Instance instance,
                                        PP_DecryptorStreamType decoder_type,
                                        uint32_t request_id) OVERRIDE;
   virtual void DecoderResetDone(PP_Instance instance,
                                 PP_DecryptorStreamType decoder_type,
                                 uint32_t request_id) OVERRIDE;
   virtual void DeliverFrame(PP_Instance instance,
                             PP_Resource decrypted_frame,
                             const PP_DecryptedFrameInfo* frame_info) OVERRIDE;
-  virtual void DeliverSamples(
-      PP_Instance instance,
-      PP_Resource audio_frames,
-      const PP_DecryptedSampleInfo* sample_info) OVERRIDE;
+  virtual void DeliverSamples(PP_Instance instance,
+                              PP_Resource audio_frames,
+                              const PP_DecryptedSampleInfo* sample_info)
+      OVERRIDE;
 
   // Reset this instance as proxied. Assigns the instance a new module, resets
   // cached interfaces to point to the out-of-process proxy and re-sends
   // DidCreate, DidChangeView, and HandleDocumentLoad (if necessary).
   // This should be used only when switching an in-process instance to an
   // external out-of-process instance.
   PP_ExternalPluginResult ResetAsProxied(scoped_refptr<PluginModule> module);
 
   // Checks whether this is a valid instance of the given module. After calling
   // ResetAsProxied above, a NaCl plugin instance's module changes, so external
@@ skipping 51 matching lines @@
   // Implements PPB_Gamepad_API. This is just to avoid having an excessive
   // number of interfaces implemented by PepperPluginInstanceImpl.
   class GamepadImpl : public ppapi::thunk::PPB_Gamepad_API,
                       public ppapi::Resource {
    public:
     GamepadImpl();
     // Resource implementation.
     virtual ppapi::thunk::PPB_Gamepad_API* AsPPB_Gamepad_API() OVERRIDE;
     virtual void Sample(PP_Instance instance,
                         PP_GamepadsSampleData* data) OVERRIDE;
+
    private:
     virtual ~GamepadImpl();
   };
 
   // See the static Create functions above for creating PepperPluginInstanceImpl
   // objects. This constructor is private so that we can hide the
   // PPP_Instance_Combined details while still having 1 constructor to maintain
   // for member initialization.
   PepperPluginInstanceImpl(RenderFrameImpl* render_frame,
                            PluginModule* module,
@@ skipping 49 matching lines @@
   void UpdateLayer();
 
   // Internal helper function for PrintPage().
   bool PrintPageHelper(PP_PrintPageNumberRange_Dev* page_ranges,
                        int num_ranges,
                        blink::WebCanvas* canvas);
 
   void DoSetCursor(blink::WebCursorInfo* cursor);
 
   // Internal helper functions for HandleCompositionXXX().
-  bool SendCompositionEventToPlugin(
-      PP_InputEvent_Type type,
-      const base::string16& text);
+  bool SendCompositionEventToPlugin(PP_InputEvent_Type type,
+                                    const base::string16& text);
   bool SendCompositionEventWithUnderlineInformationToPlugin(
       PP_InputEvent_Type type,
       const base::string16& text,
       const std::vector<blink::WebCompositionUnderline>& underlines,
       int selection_start,
       int selection_end);
 
   // Internal helper function for XXXInputEvents().
   void RequestInputEventsHelper(uint32_t event_classes);
 
@@ skipping 10 matching lines @@
   void KeepSizeAttributesBeforeFullscreen();
   void SetSizeAttributesForFullscreen();
   void ResetSizeAttributesAfterFullscreen();
 
   bool IsMouseLocked();
   bool LockMouse();
   MouseLockDispatcher* GetMouseLockDispatcher();
   MouseLockDispatcher::LockTarget* GetOrCreateLockTargetAdapter();
   void UnSetAndDeleteLockTargetAdapter();
 
-  void DidDataFromWebURLResponse(
-      const blink::WebURLResponse& response,
-      int pending_host_id,
-      const ppapi::URLResponseInfoData& data);
+  void DidDataFromWebURLResponse(const blink::WebURLResponse& response,
+                                 int pending_host_id,
+                                 const ppapi::URLResponseInfoData& data);
 
   RenderFrameImpl* render_frame_;
   base::Closure instance_deleted_callback_;
   scoped_refptr<PluginModule> module_;
   scoped_ptr<ppapi::PPP_Instance_Combined> instance_interface_;
   // If this is the NaCl plugin, we create a new module when we switch to the
   // IPC-based PPAPI proxy. Store the original module and instance interface
   // so we can shut down properly.
   scoped_refptr<PluginModule> original_module_;
   scoped_ptr<ppapi::PPP_Instance_Combined> original_instance_interface_;
@@ skipping 207 matching lines @@
   base::WeakPtrFactory<PepperPluginInstanceImpl> view_change_weak_ptr_factory_;
   base::WeakPtrFactory<PepperPluginInstanceImpl> weak_factory_;
 
   friend class PpapiPluginInstanceTest;
   DISALLOW_COPY_AND_ASSIGN(PepperPluginInstanceImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_PEPPER_PEPPER_PLUGIN_INSTANCE_IMPL_H_