Separate agg-authored code from fx-authored code.chromium/2439chromium/2438chromium/2437chromium/2436chromium/2435

Creates a separate library so we can apply less-strict warnings to
the code we can't change from upstream vs. the code we can change,
reducing noise in the standalone build.

Remove needless foo.{cpp,h} files that merely perform indirection
via #include "some_other_path/foo.{cpp,h}".

BUG=pdfium:166
R=brucedawson@chromium.org, thestig@chromium.org

Review URL: https://codereview.chromium.org/1152743007.

1 files changed, 272 insertions, 0 deletions

diff --git a/third_party/agg23/agg_math_stroke.h b/third_party/agg23/agg_math_stroke.h
new file mode 100644
index 0000000000..620d675312
--- /dev/null
+++ b/third_party/agg23/agg_math_stroke.h
@@ -0,0 +1,272 @@
+
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.3
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Stroke math
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_STROKE_MATH_INCLUDED
+#define AGG_STROKE_MATH_INCLUDED
+#include "agg_math.h"
+#include "agg_vertex_sequence.h"
+namespace agg
+{
+enum line_cap_e {
+    butt_cap,
+    square_cap,
+    round_cap
+};
+enum line_join_e {
+    miter_join         = 0,
+    miter_join_revert  = 1,
+    miter_join_round   = 4,
+    round_join         = 2,
+    bevel_join         = 3
+};
+enum inner_join_e {
+    inner_bevel,
+    inner_miter,
+    inner_jag,
+    inner_round
+};
+const FX_FLOAT stroke_theta = 1.0f / 1000.0f;
+template<class VertexConsumer>
+void stroke_calc_arc(VertexConsumer& out_vertices,
+                     FX_FLOAT x,   FX_FLOAT y,
+                     FX_FLOAT dx1, FX_FLOAT dy1,
+                     FX_FLOAT dx2, FX_FLOAT dy2,
+                     FX_FLOAT width,
+                     FX_FLOAT approximation_scale)
+{
+    typedef typename VertexConsumer::value_type coord_type;
+    FX_FLOAT a1 = FXSYS_atan2(dy1, dx1);
+    FX_FLOAT a2 = FXSYS_atan2(dy2, dx2);
+    FX_FLOAT da = a1 - a2;
+    bool ccw = da > 0 && da < FX_PI;
+    if(width < 0) {
+        width = -width;
+    }
+    da = FXSYS_acos(FXSYS_Div(width, width + FXSYS_Div(1.0f / 8, approximation_scale))) * 2;
+    out_vertices.add(coord_type(x + dx1, y + dy1));
+    if(!ccw) {
+        if(a1 > a2) {
+            a2 += 2 * FX_PI;
+        }
+        a2 -= da / 4;
+        a1 += da;
+        while(a1 < a2) {
+            out_vertices.add(coord_type(x + FXSYS_Mul(width, FXSYS_cos(a1)),
+                                        y + FXSYS_Mul(width, FXSYS_sin(a1))));
+            a1 += da;
+        }
+    } else {
+        if(a1 < a2) {
+            a2 -= 2 * FX_PI;
+        }
+        a2 += da / 4;
+        a1 -= da;
+        while(a1 > a2) {
+            out_vertices.add(coord_type(x + FXSYS_Mul(width, FXSYS_cos(a1)),
+                                        y + FXSYS_Mul(width, FXSYS_sin(a1))));
+            a1 -= da;
+        }
+    }
+    out_vertices.add(coord_type(x + dx2, y + dy2));
+}
+template<class VertexConsumer>
+void stroke_calc_miter(VertexConsumer& out_vertices,
+                       const vertex_dist& v0,
+                       const vertex_dist& v1,
+                       const vertex_dist& v2,
+                       FX_FLOAT dx1, FX_FLOAT dy1,
+                       FX_FLOAT dx2, FX_FLOAT dy2,
+                       FX_FLOAT width,
+                       line_join_e line_join,
+                       FX_FLOAT miter_limit,
+                       FX_FLOAT approximation_scale)
+{
+    typedef typename VertexConsumer::value_type coord_type;
+    FX_FLOAT xi = v1.x;
+    FX_FLOAT yi = v1.y;
+    bool miter_limit_exceeded = true;
+    if(calc_intersection(v0.x + dx1, v0.y - dy1,
+                         v1.x + dx1, v1.y - dy1,
+                         v1.x + dx2, v1.y - dy2,
+                         v2.x + dx2, v2.y - dy2,
+                         &xi, &yi)) {
+        FX_FLOAT d1 = calc_distance(v1.x, v1.y, xi, yi);
+        FX_FLOAT lim = FXSYS_Mul(width, miter_limit);
+        if(d1 <= lim) {
+            out_vertices.add(coord_type(xi, yi));
+            miter_limit_exceeded = false;
+        }
+    } else {
+        FX_FLOAT x2 = v1.x + dx1;
+        FX_FLOAT y2 = v1.y - dy1;
+        if((FXSYS_Mul(x2 - v0.x, dy1) - FXSYS_Mul(v0.y - y2, dx1) < 0) !=
+                (FXSYS_Mul(x2 - v2.x, dy1) - FXSYS_Mul(v2.y - y2, dx1) < 0)) {
+            out_vertices.add(coord_type(v1.x + dx1, v1.y - dy1));
+            miter_limit_exceeded = false;
+        }
+    }
+    if(miter_limit_exceeded) {
+        switch(line_join) {
+            case miter_join_revert:
+                out_vertices.add(coord_type(v1.x + dx1, v1.y - dy1));
+                out_vertices.add(coord_type(v1.x + dx2, v1.y - dy2));
+                break;
+            case miter_join_round:
+                stroke_calc_arc(out_vertices,
+                                v1.x, v1.y, dx1, -dy1, dx2, -dy2,
+                                width, approximation_scale);
+                break;
+            default:
+                out_vertices.add(coord_type(v1.x + dx1 + FXSYS_Mul(dy1, miter_limit),
+                                            v1.y - dy1 + FXSYS_Mul(dx1, miter_limit)));
+                out_vertices.add(coord_type(v1.x + dx2 - FXSYS_Mul(dy2, miter_limit),
+                                            v1.y - dy2 - FXSYS_Mul(dx2, miter_limit)));
+                break;
+        }
+    }
+}
+template<class VertexConsumer>
+void stroke_calc_cap(VertexConsumer& out_vertices,
+                     const vertex_dist& v0,
+                     const vertex_dist& v1,
+                     FX_FLOAT len,
+                     line_cap_e line_cap,
+                     FX_FLOAT width,
+                     FX_FLOAT approximation_scale)
+{
+    typedef typename VertexConsumer::value_type coord_type;
+    out_vertices.remove_all();
+    FX_FLOAT dx1 = FXSYS_Div(v1.y - v0.y, len);
+    FX_FLOAT dy1 = FXSYS_Div(v1.x - v0.x, len);
+    FX_FLOAT dx2 = 0;
+    FX_FLOAT dy2 = 0;
+    dx1 = FXSYS_Mul(dx1, width);
+    dy1 = FXSYS_Mul(dy1, width);
+    if(line_cap != round_cap) {
+        if(line_cap == square_cap) {
+            dx2 = dy1;
+            dy2 = dx1;
+        }
+        out_vertices.add(coord_type(v0.x - dx1 - dx2, v0.y + dy1 - dy2));
+        out_vertices.add(coord_type(v0.x + dx1 - dx2, v0.y - dy1 - dy2));
+    } else {
+        FX_FLOAT a1 = FXSYS_atan2(dy1, -dx1);
+        FX_FLOAT a2 = a1 + FX_PI;
+        FX_FLOAT da = FXSYS_acos(FXSYS_Div(width, width +
+                                           FXSYS_Div(1.0f / 8, approximation_scale))) * 2;
+        out_vertices.add(coord_type(v0.x - dx1, v0.y + dy1));
+        a1 += da;
+        a2 -= da / 4;
+        while(a1 < a2) {
+            out_vertices.add(coord_type(v0.x + FXSYS_Mul(width, FXSYS_cos(a1)),
+                                        v0.y + FXSYS_Mul(width, FXSYS_sin(a1))));
+            a1 += da;
+        }
+        out_vertices.add(coord_type(v0.x + dx1, v0.y - dy1));
+    }
+}
+template<class VertexConsumer>
+void stroke_calc_join(VertexConsumer& out_vertices,
+                      const vertex_dist& v0,
+                      const vertex_dist& v1,
+                      const vertex_dist& v2,
+                      FX_FLOAT len1,
+                      FX_FLOAT len2,
+                      FX_FLOAT width,
+                      line_join_e line_join,
+                      inner_join_e inner_join,
+                      FX_FLOAT miter_limit,
+                      FX_FLOAT inner_miter_limit,
+                      FX_FLOAT approximation_scale)
+{
+    typedef typename VertexConsumer::value_type coord_type;
+    FX_FLOAT dx1, dy1, dx2, dy2;
+    dx1 = FXSYS_MulDiv(width, v1.y - v0.y, len1);
+    dy1 = FXSYS_MulDiv(width, v1.x - v0.x, len1);
+    dx2 = FXSYS_MulDiv(width, v2.y - v1.y, len2);
+    dy2 = FXSYS_MulDiv(width, v2.x - v1.x, len2);
+    out_vertices.remove_all();
+    if(calc_point_location(v0.x, v0.y, v1.x, v1.y, v2.x, v2.y) > 0) {
+        switch(inner_join) {
+            default:
+                out_vertices.add(coord_type(v1.x + dx1, v1.y - dy1));
+                out_vertices.add(coord_type(v1.x + dx2, v1.y - dy2));
+                break;
+            case inner_miter:
+                stroke_calc_miter(out_vertices,
+                                  v0, v1, v2, dx1, dy1, dx2, dy2,
+                                  width,
+                                  miter_join_revert,
+                                  inner_miter_limit,
+                                  1.0f);
+                break;
+            case inner_jag:
+            case inner_round: {
+                    FX_FLOAT d = (dx1 - dx2) * (dx1 - dx2) + (dy1 - dy2) * (dy1 - dy2);
+                    if(d < len1 * len1 && d < len2 * len2) {
+                        stroke_calc_miter(out_vertices,
+                                          v0, v1, v2, dx1, dy1, dx2, dy2,
+                                          width,
+                                          miter_join_revert,
+                                          inner_miter_limit,
+                                          1.0f);
+                    } else {
+                        if(inner_join == inner_jag) {
+                            out_vertices.add(coord_type(v1.x + dx1, v1.y - dy1));
+                            out_vertices.add(coord_type(v1.x,       v1.y      ));
+                            out_vertices.add(coord_type(v1.x + dx2, v1.y - dy2));
+                        } else {
+                            out_vertices.add(coord_type(v1.x + dx1, v1.y - dy1));
+                            out_vertices.add(coord_type(v1.x,       v1.y      ));
+                            stroke_calc_arc(out_vertices,
+                                            v1.x, v1.y, dx2, -dy2, dx1, -dy1,
+                                            width, approximation_scale);
+                            out_vertices.add(coord_type(v1.x,       v1.y      ));
+                            out_vertices.add(coord_type(v1.x + dx2, v1.y - dy2));
+                        }
+                    }
+                }
+                break;
+        }
+    } else {
+        switch(line_join) {
+            case miter_join:
+            case miter_join_revert:
+            case miter_join_round:
+                stroke_calc_miter(out_vertices,
+                                  v0, v1, v2, dx1, dy1, dx2, dy2,
+                                  width,
+                                  line_join,
+                                  miter_limit,
+                                  approximation_scale);
+                break;
+            case round_join:
+                stroke_calc_arc(out_vertices,
+                                v1.x, v1.y, dx1, -dy1, dx2, -dy2,
+                                width, approximation_scale);
+                break;
+            default:
+                out_vertices.add(coord_type(v1.x + dx1, v1.y - dy1));
+                out_vertices.add(coord_type(v1.x + dx2, v1.y - dy2));
+                break;
+        }
+    }
+}
+}
+#endif