Clang format pdf/

pdf/pdfium/pdfium_engine.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 PDF_PDFIUM_PDFIUM_ENGINE_H_
 #define PDF_PDFIUM_PDFIUM_ENGINE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 118 matching lines @@
 
  private:
   // This helper class is used to detect the difference in selection between
   // construction and destruction.  At destruction, it invalidates all the
   // parts that are newly selected, along with all the parts that used to be
   // selected but are not anymore.
   class SelectionChangeInvalidator {
    public:
     explicit SelectionChangeInvalidator(PDFiumEngine* engine);
     ~SelectionChangeInvalidator();
+
    private:
     // Sets the given container to the all the currently visible selection
     // rectangles, in screen coordinates.
     void GetVisibleSelectionsScreenRects(std::vector<pp::Rect>* rects);
 
     PDFiumEngine* engine_;
     // Screen rectangles that were selected on construction.
     std::vector<pp::Rect> old_selections_;
     // The origin at the time this object was constructed.
     pp::Point previous_origin_;
@@ skipping 26 matching lines @@
     ~FindTextIndex();
 
     bool valid() const { return valid_; }
     void Invalidate();
 
     size_t GetIndex() const;
     void SetIndex(size_t index);
     size_t IncrementIndex();
 
    private:
-    bool valid_;  // Whether |index_| is valid or not.
+    bool valid_;    // Whether |index_| is valid or not.
     size_t index_;  // The current search result, 0-based.
 
     DISALLOW_COPY_AND_ASSIGN(FindTextIndex);
   };
 
   friend class SelectionChangeInvalidator;
 
   struct FileAvail : public FX_FILEAVAIL {
     DocumentLoader* loader;
   };
 
   struct DownloadHints : public FX_DOWNLOADHINTS {
     DocumentLoader* loader;
   };
 
   // PDFium interface to get block of data.
-  static int GetBlock(void* param, unsigned long position,
-                      unsigned char* buffer, unsigned long size);
+  static int GetBlock(void* param,
+                      unsigned long position,
+                      unsigned char* buffer,
+                      unsigned long size);
 
   // PDFium interface to check is block of data is available.
-  static FPDF_BOOL IsDataAvail(FX_FILEAVAIL* param,
-                               size_t offset, size_t size);
+  static FPDF_BOOL IsDataAvail(FX_FILEAVAIL* param, size_t offset, size_t size);
 
   // PDFium interface to request download of the block of data.
-  static void AddSegment(FX_DOWNLOADHINTS* param,
-                         size_t offset, size_t size);
+  static void AddSegment(FX_DOWNLOADHINTS* param, size_t offset, size_t size);
 
   // We finished getting the pdf file, so load it. This will complete
   // asynchronously (due to password fetching) and may be run multiple times.
   void LoadDocument();
 
   // Try loading the document. Returns true if the document is successfully
   // loaded or is already loaded otherwise it will return false. If there is a
   // password, then |password| is non-empty. If the document could not be loaded
   // and needs a password, |needs_password| will be set to true.
   bool TryLoadingDoc(const std::string& password, bool* needs_password);
 
   // Asks the user for the document password and then continue loading the
   // document.
   void GetPasswordAndLoad();
 
   // Called when the password has been retrieved.
-  void OnGetPasswordComplete(int32_t result,
-                             const pp::Var& password);
+  void OnGetPasswordComplete(int32_t result, const pp::Var& password);
 
   // Continues loading the document when the password has been retrieved, or if
   // there is no password. If there is no password, then |password| is empty.
   void ContinueLoadingDocument(const std::string& password);
 
   // Finishes loading the document. Recalculate the document size if there were
   // pages that were not previously available.
   // Also notifies the client that the document has been loaded.
   // This should only be called after |doc_| has been loaded and the document is
   // fully downloaded.
@@ skipping 133 matching lines @@
   // Given a page index, returns the corresponding index in progressive_rects_,
   // or -1 if it doesn't exist.
   int GetProgressiveIndex(int page_index) const;
 
   // Creates a FPDF_BITMAP from a rectangle in screen coordinates.
   FPDF_BITMAP CreateBitmap(const pp::Rect& rect,
                            pp::ImageData* image_data) const;
 
   // Given a rectangle in screen coordinates, returns the coordinates in the
   // units that PDFium rendering functions expect.
-  void GetPDFiumRect(int page_index, const pp::Rect& rect, int* start_x,
-                     int* start_y, int* size_x, int* size_y) const;
+  void GetPDFiumRect(int page_index,
+                     const pp::Rect& rect,
+                     int* start_x,
+                     int* start_y,
+                     int* size_x,
+                     int* size_y) const;
 
   // Returns the rendering flags to pass to PDFium.
   int GetRenderingFlags() const;
 
   // Returns the currently visible rectangle in document coordinates.
   pp::Rect GetVisibleRect() const;
 
   // Given a rectangle in document coordinates, returns the rectange into screen
   // coordinates (i.e. 0,0 is top left corner of plugin area).  If it's not
   // visible, an empty rectangle is returned.
@@ skipping 272 matching lines @@
   FileAvail file_availability_;
   // Interface structure to request data chunks from the document stream.
   DownloadHints download_hints_;
   // Pointer to the document availability interface.
   FPDF_AVAIL fpdf_availability_;
 
   pp::Size default_page_size_;
 
   // Used to manage timers that form fill API needs.  The pair holds the timer
   // period, in ms, and the callback function.
-  std::map<int, std::pair<int, TimerCallback> > timers_;
+  std::map<int, std::pair<int, TimerCallback>> timers_;
   int next_timer_id_;
 
   // Holds the zero-based page index of the last page that the mouse clicked on.
   int last_page_mouse_down_;
 
   // Holds the zero-based page index of the most visible page; refreshed by
   // calling CalculateVisiblePages()
   int most_visible_page_;
 
   // Holds the page index requested by PDFium while the scroll operation
@@ skipping 101 matching lines @@
   bool GetPDFPageSizeByIndex(const void* pdf_buffer,
                              int pdf_buffer_size,
                              int page_number,
                              double* width,
                              double* height) override;
 };
 
 }  // namespace chrome_pdf
 
 #endif  // PDF_PDFIUM_PDFIUM_ENGINE_H_