[chromium-libs-media-freeworld: 1/8] apply upstream commit to work around EPEL7 compiler issues
by Miro Hrončok
commit bbbf61dadd948f4cd8f2a7a0677b30270a29a953
Author: Tom Callaway <spot(a)fedoraproject.org>
Date: Wed Aug 9 13:48:24 2017 -0400
apply upstream commit to work around EPEL7 compiler issues
chromium-60.0.3112.90-no-per-child.patch | 843 +++++++++++++++++++++++++++++++
chromium.spec | 11 +-
2 files changed, 853 insertions(+), 1 deletion(-)
---
diff --git a/chromium-60.0.3112.90-no-per-child.patch b/chromium-60.0.3112.90-no-per-child.patch
new file mode 100644
index 0000000..743cce2
--- /dev/null
+++ b/chromium-60.0.3112.90-no-per-child.patch
@@ -0,0 +1,843 @@
+diff -up chromium-60.0.3112.90/third_party/WebKit/Source/core/layout/ng/inline/ng_inline_layout_algorithm.cc.perchild chromium-60.0.3112.90/third_party/WebKit/Source/core/layout/ng/inline/ng_inline_layout_algorithm.cc
+--- chromium-60.0.3112.90/third_party/WebKit/Source/core/layout/ng/inline/ng_inline_layout_algorithm.cc.perchild 2017-08-02 18:05:34.000000000 -0400
++++ chromium-60.0.3112.90/third_party/WebKit/Source/core/layout/ng/inline/ng_inline_layout_algorithm.cc 2017-08-09 13:30:01.000000000 -0400
+@@ -55,11 +55,11 @@ NGInlineLayoutAlgorithm::NGInlineLayoutA
+ // Only resolve our BFC offset if we know that we are non-empty as we may
+ // need to pass through our margin strut.
+ if (!inline_node->Items().IsEmpty()) {
+- NGLogicalOffset bfc_offset = ConstraintSpace().BfcOffset();
+- bfc_offset.block_offset += ConstraintSpace().MarginStrut().Sum();
+- MaybeUpdateFragmentBfcOffset(ConstraintSpace(), bfc_offset,
++ LayoutUnit bfc_block_offset = ConstraintSpace().BfcOffset().block_offset;
++ bfc_block_offset += ConstraintSpace().MarginStrut().Sum();
++ MaybeUpdateFragmentBfcOffset(ConstraintSpace(), bfc_block_offset,
+ &container_builder_);
+- PositionPendingFloats(bfc_offset.block_offset, &container_builder_,
++ PositionPendingFloats(bfc_block_offset, &container_builder_,
+ MutableConstraintSpace());
+ }
+
+@@ -222,6 +222,7 @@ bool NGInlineLayoutAlgorithm::PlaceItems
+ NGLineHeightMetrics line_metrics_with_leading = line_metrics;
+ line_metrics_with_leading.AddLeading(line_style.ComputedLineHeightAsFixed());
+ NGLineBoxFragmentBuilder line_box(Node());
++ line_box.SetWritingMode(ConstraintSpace().WritingMode());
+
+ // Compute heights of all inline items by placing the dominant baseline at 0.
+ // The baseline is adjusted after the height of the line box is computed.
+@@ -231,8 +232,7 @@ bool NGInlineLayoutAlgorithm::PlaceItems
+
+ // Place items from line-left to line-right along with the baseline.
+ // Items are already bidi-reordered to the visual order.
+- LayoutUnit line_left_position = LogicalLeftOffset();
+- LayoutUnit position = line_left_position;
++ LayoutUnit position;
+
+ for (auto& item_result : *line_items) {
+ const NGInlineItem& item = items[item_result.item_index];
+@@ -253,13 +253,28 @@ bool NGInlineLayoutAlgorithm::PlaceItems
+ item_result.end_offset);
+ line_box.AddChild(std::move(text_fragment), {position, box->text_top});
+ } else if (item.Type() == NGInlineItem::kOpenTag) {
+- box = box_states_.OnOpenTag(item, &line_box, &text_builder);
++ box = box_states_.OnOpenTag(item, &line_box);
+ // Compute text metrics for all inline boxes since even empty inlines
+ // influence the line height.
+ // https://drafts.csswg.org/css2/visudet.html#line-height
+ box->ComputeTextMetrics(*item.Style(), baseline_type_);
++ text_builder.SetDirection(box->style->Direction());
++ // TODO(kojii): We may need more conditions to create box fragments.
++ if (item.Style()->HasBoxDecorationBackground()) {
++ // TODO(kojii): These are once computed in NGLineBreaker. Should copy to
++ // NGInlineItemResult to reuse here.
++ NGBoxStrut borders = ComputeBorders(*constraint_space_, *item.Style());
++ NGBoxStrut paddings = ComputePadding(*constraint_space_, *item.Style());
++ // TODO(kojii): Set paint edges.
++ box->SetNeedsBoxFragment(position,
++ borders.block_start + paddings.block_start,
++ borders.BlockSum() + paddings.BlockSum());
++ }
+ } else if (item.Type() == NGInlineItem::kCloseTag) {
+- box = box_states_.OnCloseTag(item, &line_box, box, baseline_type_);
++ position += item_result.inline_size;
++ box = box_states_.OnCloseTag(item, &line_box, box, baseline_type_,
++ position);
++ continue;
+ } else if (item.Type() == NGInlineItem::kAtomicInline) {
+ box = PlaceAtomicInline(item, &item_result, position, &line_box,
+ &text_builder);
+@@ -286,12 +301,11 @@ bool NGInlineLayoutAlgorithm::PlaceItems
+ return true; // The line was empty.
+ }
+
+- box_states_.OnEndPlaceItems(&line_box, baseline_type_);
++ box_states_.OnEndPlaceItems(&line_box, baseline_type_, position);
+
+ // The baselines are always placed at pixel boundaries. Not doing so results
+ // in incorrect layout of text decorations, most notably underlines.
+- LayoutUnit baseline = content_size_ + line_box.Metrics().ascent +
+- border_and_padding_.block_start;
++ LayoutUnit baseline = content_size_ + line_box.Metrics().ascent;
+ baseline = LayoutUnit(baseline.Round());
+
+ // Check if the line fits into the constraint space in block direction.
+@@ -313,19 +327,14 @@ bool NGInlineLayoutAlgorithm::PlaceItems
+ // the line box to the line top.
+ line_box.MoveChildrenInBlockDirection(baseline);
+
+- DCHECK_EQ(line_left_position, LogicalLeftOffset());
+- LayoutUnit inline_size = position - line_left_position;
+- line_box.SetInlineSize(inline_size);
+-
+- // Account for text align property.
+- if (Node()->Style().GetTextAlign() == ETextAlign::kRight) {
+- line_box.MoveChildrenInInlineDirection(
+- current_opportunity_.size.inline_size - inline_size);
+- }
++ LayoutUnit inline_size = position;
++ NGLogicalOffset offset(LogicalLeftOffset(),
++ baseline - box_states_.LineBoxState().metrics.ascent);
++ ApplyTextAlign(&offset.inline_offset, inline_size,
++ current_opportunity_.size.inline_size);
+
+- container_builder_.AddChild(
+- line_box.ToLineBoxFragment(),
+- {LayoutUnit(), baseline - box_states_.LineBoxState().metrics.ascent});
++ line_box.SetInlineSize(inline_size);
++ container_builder_.AddChild(line_box.ToLineBoxFragment(), offset);
+
+ max_inline_size_ = std::max(max_inline_size_, inline_size);
+ content_size_ = line_bottom;
+@@ -342,7 +351,7 @@ NGInlineBoxState* NGInlineLayoutAlgorith
+ NGTextFragmentBuilder* text_builder) {
+ DCHECK(item_result->layout_result);
+
+- NGInlineBoxState* box = box_states_.OnOpenTag(item, line_box, text_builder);
++ NGInlineBoxState* box = box_states_.OnOpenTag(item, line_box);
+
+ // For replaced elements, inline-block elements, and inline-table elements,
+ // the height is the height of their margin box.
+@@ -371,6 +380,7 @@ NGInlineBoxState* NGInlineLayoutAlgorith
+ // TODO(kojii): Try to eliminate the wrapping text fragment and use the
+ // |fragment| directly. Currently |CopyFragmentDataToLayoutBlockFlow|
+ // requires a text fragment.
++ text_builder->SetDirection(item.Style()->Direction());
+ text_builder->SetSize({fragment.InlineSize(), block_size});
+ LayoutUnit line_top = item_result->margins.block_start - metrics.ascent;
+ RefPtr<NGPhysicalTextFragment> text_fragment = text_builder->ToTextFragment(
+@@ -378,7 +388,31 @@ NGInlineBoxState* NGInlineLayoutAlgorith
+ item_result->end_offset);
+ line_box->AddChild(std::move(text_fragment), {position, line_top});
+
+- return box_states_.OnCloseTag(item, line_box, box, baseline_type_);
++ return box_states_.OnCloseTag(item, line_box, box, baseline_type_,
++ LayoutUnit(0));
++}
++
++void NGInlineLayoutAlgorithm::ApplyTextAlign(LayoutUnit* line_left,
++ LayoutUnit inline_size,
++ LayoutUnit available_width) {
++ // TODO(kojii): Implement text-align-last.
++ ETextAlign text_align = LineStyle().GetTextAlign();
++ switch (text_align) {
++ case ETextAlign::kRight:
++ case ETextAlign::kWebkitRight:
++ // Wide lines spill out of the block based off direction.
++ // So even if text-align is right, if direction is LTR, wide lines should
++ // overflow out of the right side of the block.
++ // TODO(kojii): Investigate how to handle trailing spaces.
++ if (inline_size < available_width ||
++ !LineStyle().IsLeftToRightDirection())
++ *line_left += available_width - inline_size;
++ break;
++ default:
++ // TODO(layout-dev): Implement.
++ // Refer to LayoutBlockFlow::UpdateLogicalWidthForAlignment().
++ break;
++ }
+ }
+
+ void NGInlineLayoutAlgorithm::FindNextLayoutOpportunity() {
+@@ -396,6 +430,10 @@ void NGInlineLayoutAlgorithm::FindNextLa
+ }
+
+ RefPtr<NGLayoutResult> NGInlineLayoutAlgorithm::Layout() {
++ // If we are resuming from a break token our start border and padding is
++ // within a previous fragment.
++ content_size_ = BreakToken() ? LayoutUnit() : border_and_padding_.block_start;
++
+ NGLineBreaker line_breaker(Node(), constraint_space_, BreakToken());
+ NGInlineItemResults item_results;
+ while (true) {
+@@ -407,7 +445,7 @@ RefPtr<NGLayoutResult> NGInlineLayoutAlg
+ }
+
+ // TODO(crbug.com/716930): Avoid calculating border/padding twice.
+- if (!Node()->Items().IsEmpty())
++ if (!BreakToken())
+ content_size_ -= border_and_padding_.block_start;
+
+ // TODO(kojii): Check if the line box width should be content or available.
+diff -up chromium-60.0.3112.90/third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.cc.perchild chromium-60.0.3112.90/third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.cc
+--- chromium-60.0.3112.90/third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.cc.perchild 2017-08-02 18:05:34.000000000 -0400
++++ chromium-60.0.3112.90/third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.cc 2017-08-09 13:30:01.000000000 -0400
+@@ -67,14 +67,31 @@ bool IsOutOfSpace(const NGConstraintSpac
+
+ } // namespace
+
++// This struct is used for communicating to a child the position of the
++// previous inflow child.
++struct NGPreviousInflowPosition {
++ LayoutUnit bfc_block_offset;
++ LayoutUnit logical_block_offset;
++ NGMarginStrut margin_strut;
++};
++
++// This strut holds information for the current inflow child. The data is not
++// useful outside of handling this single inflow child.
++struct NGInflowChildData {
++ NGLogicalOffset bfc_offset_estimate;
++ NGMarginStrut margin_strut;
++ NGBoxStrut margins;
++};
++
+ void MaybeUpdateFragmentBfcOffset(const NGConstraintSpace& space,
+- const NGLogicalOffset& offset,
++ LayoutUnit bfc_block_offset,
+ NGFragmentBuilder* builder) {
+ DCHECK(builder);
+ if (!builder->BfcOffset()) {
+- NGLogicalOffset mutable_offset(offset);
+- AdjustToClearance(space.ClearanceOffset(), &mutable_offset);
+- builder->SetBfcOffset(mutable_offset);
++ NGLogicalOffset bfc_offset = {space.BfcOffset().inline_offset,
++ bfc_block_offset};
++ AdjustToClearance(space.ClearanceOffset(), &bfc_offset);
++ builder->SetBfcOffset(bfc_offset);
+ }
+ }
+
+@@ -150,11 +167,13 @@ Optional<MinMaxContentSize> NGBlockLayou
+ }
+
+ NGLogicalOffset NGBlockLayoutAlgorithm::CalculateLogicalOffset(
++ const NGBoxStrut& child_margins,
+ const WTF::Optional<NGLogicalOffset>& known_fragment_offset) {
+ if (known_fragment_offset)
+ return known_fragment_offset.value() - ContainerBfcOffset();
+ LayoutUnit inline_offset =
+- border_and_padding_.inline_start + curr_child_margins_.inline_start;
++ border_and_padding_.inline_start + child_margins.inline_start;
++ // TODO(ikilpatrick): Using the content_size_ here looks suspicious - check.
+ return {inline_offset, content_size_};
+ }
+
+@@ -199,17 +218,20 @@ RefPtr<NGLayoutResult> NGBlockLayoutAlgo
+ // within a previous fragment.
+ content_size_ = BreakToken() ? LayoutUnit() : border_and_padding_.block_start;
+
+- curr_margin_strut_ = ConstraintSpace().MarginStrut();
+- curr_bfc_offset_ = ConstraintSpace().BfcOffset();
++ NGMarginStrut input_margin_strut = ConstraintSpace().MarginStrut();
++ LayoutUnit input_bfc_block_offset =
++ ConstraintSpace().BfcOffset().block_offset;
+
+ // Margins collapsing:
+ // Do not collapse margins between parent and its child if there is
+ // border/padding between them.
+ if (border_and_padding_.block_start) {
+- curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
+- MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_,
++ input_bfc_block_offset += input_margin_strut.Sum();
++ MaybeUpdateFragmentBfcOffset(ConstraintSpace(), input_bfc_block_offset,
+ &container_builder_);
+- curr_margin_strut_ = NGMarginStrut();
++ // We reset the block offset here as it may have been effected by clearance.
++ input_bfc_block_offset = ContainerBfcOffset().block_offset;
++ input_margin_strut = NGMarginStrut();
+ }
+
+ // If a new formatting context hits the margin collapsing if-branch above
+@@ -218,29 +240,34 @@ RefPtr<NGLayoutResult> NGBlockLayoutAlgo
+ // If we are resuming layout from a break token the same rule applies. Margin
+ // struts cannot pass through break tokens.
+ if (ConstraintSpace().IsNewFormattingContext() || BreakToken()) {
+- MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_,
++ MaybeUpdateFragmentBfcOffset(ConstraintSpace(), input_bfc_block_offset,
+ &container_builder_);
+- DCHECK_EQ(curr_margin_strut_, NGMarginStrut());
++ DCHECK_EQ(input_margin_strut, NGMarginStrut());
+ DCHECK_EQ(container_builder_.BfcOffset().value(), NGLogicalOffset());
+- curr_bfc_offset_ = {};
+ }
+
+- curr_bfc_offset_.block_offset += content_size_;
++ input_bfc_block_offset += content_size_;
++
++ NGPreviousInflowPosition previous_inflow_position = {
++ input_bfc_block_offset, content_size_, input_margin_strut};
+
+ while (child) {
+ if (child->IsOutOfFlowPositioned()) {
+ DCHECK(!child_break_token);
+- HandleOutOfFlowPositioned(ToNGBlockNode(child));
++ HandleOutOfFlowPositioned(previous_inflow_position, ToNGBlockNode(child));
+ } else if (child->IsFloating()) {
+- HandleFloating(ToNGBlockNode(child),
++ HandleFloating(previous_inflow_position, ToNGBlockNode(child),
+ ToNGBlockBreakToken(child_break_token));
+ } else {
+- NGLogicalOffset child_bfc_offset = PrepareChildLayout(child);
++ NGInflowChildData child_data =
++ PrepareChildLayout(previous_inflow_position, child);
+ RefPtr<NGConstraintSpace> child_space =
+- CreateConstraintSpaceForChild(child_bfc_offset, *child);
++ CreateConstraintSpaceForChild(*child, child_data);
+ RefPtr<NGLayoutResult> layout_result =
+ child->Layout(child_space.Get(), child_break_token);
+- FinishChildLayout(*child_space, child, layout_result.Get());
++ previous_inflow_position =
++ FinishChildLayout(*child_space, previous_inflow_position, child_data,
++ child, layout_result.Get());
+ }
+
+ entry = child_iterator.NextChild();
+@@ -251,6 +278,9 @@ RefPtr<NGLayoutResult> NGBlockLayoutAlgo
+ break;
+ }
+
++ NGMarginStrut end_margin_strut = previous_inflow_position.margin_strut;
++ LayoutUnit end_bfc_block_offset = previous_inflow_position.bfc_block_offset;
++
+ // Margins collapsing:
+ // Bottom margins of an in-flow block box doesn't collapse with its last
+ // in-flow block-level child's bottom margin if the box has bottom
+@@ -258,8 +288,8 @@ RefPtr<NGLayoutResult> NGBlockLayoutAlgo
+ content_size_ += border_and_padding_.block_end;
+ if (border_and_padding_.block_end ||
+ ConstraintSpace().IsNewFormattingContext()) {
+- content_size_ += curr_margin_strut_.Sum();
+- curr_margin_strut_ = NGMarginStrut();
++ content_size_ += end_margin_strut.Sum();
++ end_margin_strut = NGMarginStrut();
+ }
+
+ // Recompute the block-axis size now that we know our content size.
+@@ -273,10 +303,10 @@ RefPtr<NGLayoutResult> NGBlockLayoutAlgo
+ // Non-empty blocks always know their position in space.
+ // TODO(ikilpatrick): This check for a break token seems error prone.
+ if (size.block_size || BreakToken()) {
+- curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
+- MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_,
++ end_bfc_block_offset += end_margin_strut.Sum();
++ MaybeUpdateFragmentBfcOffset(ConstraintSpace(), end_bfc_block_offset,
+ &container_builder_);
+- PositionPendingFloats(curr_bfc_offset_.block_offset, &container_builder_,
++ PositionPendingFloats(end_bfc_block_offset, &container_builder_,
+ MutableConstraintSpace());
+ }
+
+@@ -285,9 +315,9 @@ RefPtr<NGLayoutResult> NGBlockLayoutAlgo
+ // of its parent if the parent has height != auto()
+ if (!Style().LogicalHeight().IsAuto()) {
+ // TODO(glebl): handle minLogicalHeight, maxLogicalHeight.
+- curr_margin_strut_ = NGMarginStrut();
++ end_margin_strut = NGMarginStrut();
+ }
+- container_builder_.SetEndMarginStrut(curr_margin_strut_);
++ container_builder_.SetEndMarginStrut(end_margin_strut);
+
+ container_builder_.SetOverflowSize(
+ NGLogicalSize(max_inline_size_, content_size_));
+@@ -302,33 +332,32 @@ RefPtr<NGLayoutResult> NGBlockLayoutAlgo
+ return container_builder_.ToBoxFragment();
+ }
+
+-void NGBlockLayoutAlgorithm::HandleOutOfFlowPositioned(NGBlockNode* child) {
+- NGLogicalOffset offset = {border_and_padding_.inline_start, content_size_};
++void NGBlockLayoutAlgorithm::HandleOutOfFlowPositioned(
++ const NGPreviousInflowPosition& previous_inflow_position,
++ NGBlockNode* child) {
++ NGLogicalOffset offset = {border_and_padding_.inline_start,
++ previous_inflow_position.logical_block_offset};
+
+ // We only include the margin strut in the OOF static-position if we know we
+ // aren't going to be a zero-block-size fragment.
+ if (container_builder_.BfcOffset())
+- offset.block_offset += curr_margin_strut_.Sum();
++ offset.block_offset += previous_inflow_position.margin_strut.Sum();
+
+ container_builder_.AddOutOfFlowChildCandidate(child, offset);
+ }
+
+-void NGBlockLayoutAlgorithm::HandleFloating(NGBlockNode* child,
+- NGBlockBreakToken* token) {
+- // TODO(ikilpatrick): Pass in BFC offset from previous in-flow child.
+- curr_bfc_offset_ = container_builder_.BfcOffset()
+- ? container_builder_.BfcOffset().value()
+- : ConstraintSpace().BfcOffset();
+- curr_bfc_offset_.block_offset += content_size_;
+-
++void NGBlockLayoutAlgorithm::HandleFloating(
++ const NGPreviousInflowPosition& previous_inflow_position,
++ NGBlockNode* child,
++ NGBlockBreakToken* token) {
+ // Calculate margins in the BFC's writing mode.
+- curr_child_margins_ = CalculateMargins(child);
++ NGBoxStrut margins = CalculateMargins(child);
+
+ NGLogicalOffset origin_offset = constraint_space_->BfcOffset();
+ origin_offset.inline_offset += border_and_padding_.inline_start;
+ RefPtr<NGUnpositionedFloat> unpositioned_float = NGUnpositionedFloat::Create(
+ child_available_size_, child_percentage_size_, origin_offset,
+- constraint_space_->BfcOffset(), curr_child_margins_, child, token);
++ constraint_space_->BfcOffset(), margins, child, token);
+ container_builder_.AddUnpositionedFloat(unpositioned_float);
+
+ // If there is a break token for a float we must be resuming layout, we must
+@@ -337,29 +366,28 @@ void NGBlockLayoutAlgorithm::HandleFloat
+
+ // No need to postpone the positioning if we know the correct offset.
+ if (container_builder_.BfcOffset()) {
+- NGLogicalOffset origin_point = curr_bfc_offset_;
+ // Adjust origin point to the margins of the last child.
+ // Example: <div style="margin-bottom: 20px"><float></div>
+ // <div style="margin-bottom: 30px"></div>
+- origin_point.block_offset += curr_margin_strut_.Sum();
+- PositionPendingFloats(origin_point.block_offset, &container_builder_,
++ LayoutUnit origin_block_offset =
++ previous_inflow_position.bfc_block_offset +
++ previous_inflow_position.margin_strut.Sum();
++ PositionPendingFloats(origin_block_offset, &container_builder_,
+ MutableConstraintSpace());
+ }
+ }
+
+-NGLogicalOffset NGBlockLayoutAlgorithm::PrepareChildLayout(
++NGInflowChildData NGBlockLayoutAlgorithm::PrepareChildLayout(
++ const NGPreviousInflowPosition& previous_inflow_position,
+ NGLayoutInputNode* child) {
+ DCHECK(child);
+ DCHECK(!child->IsFloating());
+
+- // TODO(ikilpatrick): Pass in BFC offset from previous in-flow child.
+- curr_bfc_offset_ = container_builder_.BfcOffset()
+- ? container_builder_.BfcOffset().value()
+- : ConstraintSpace().BfcOffset();
+- curr_bfc_offset_.block_offset += content_size_;
++ LayoutUnit bfc_block_offset = previous_inflow_position.bfc_block_offset;
+
+ // Calculate margins in parent's writing mode.
+- curr_child_margins_ = CalculateMargins(child);
++ NGBoxStrut margins = CalculateMargins(child);
++ NGMarginStrut margin_strut = previous_inflow_position.margin_strut;
+
+ bool should_position_pending_floats =
+ !IsNewFormattingContextForBlockLevelChild(Style(), *child) &&
+@@ -371,45 +399,50 @@ NGLogicalOffset NGBlockLayoutAlgorithm::
+ // be positioned before layout. This also resolves the fragment's bfc offset.
+ if (should_position_pending_floats) {
+ LayoutUnit origin_point_block_offset =
+- curr_bfc_offset_.block_offset + curr_margin_strut_.Sum();
+- MaybeUpdateFragmentBfcOffset(
+- ConstraintSpace(),
+- {curr_bfc_offset_.inline_offset, origin_point_block_offset},
+- &container_builder_);
++ bfc_block_offset + margin_strut.Sum();
++ MaybeUpdateFragmentBfcOffset(ConstraintSpace(), origin_point_block_offset,
++ &container_builder_);
++ // TODO(ikilpatrick): Check if origin_point_block_offset is correct -
++ // MaybeUpdateFragmentBfcOffset might have changed it due to clearance.
+ PositionPendingFloats(origin_point_block_offset, &container_builder_,
+ MutableConstraintSpace());
+ }
+
+- NGLogicalOffset child_bfc_offset = curr_bfc_offset_;
+- child_bfc_offset.inline_offset +=
+- {border_and_padding_.inline_start + curr_child_margins_.inline_start};
++ NGLogicalOffset child_bfc_offset = {
++ ConstraintSpace().BfcOffset().inline_offset +
++ border_and_padding_.inline_start + margins.inline_start,
++ bfc_block_offset};
++
++ bool is_new_fc = IsNewFormattingContextForBlockLevelChild(Style(), *child);
+
+ // Append the current margin strut with child's block start margin.
+ // Non empty border/padding, and new FC use cases are handled inside of the
+ // child's layout.
+- if (!IsNewFormattingContextForBlockLevelChild(Style(), *child))
+- curr_margin_strut_.Append(curr_child_margins_.block_start);
++ if (!is_new_fc)
++ margin_strut.Append(margins.block_start);
+
+ // TODO(crbug.com/716930): We should also collapse margins below once we
+ // remove LayoutInline splitting.
+
+ // Should collapse margins if our child is a legacy block.
+- if (IsLegacyBlock(*child)) {
+- curr_bfc_offset_ +=
+- {border_and_padding_.inline_start + curr_child_margins_.inline_start,
+- curr_margin_strut_.Sum()};
+- MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_,
+- &container_builder_);
+- PositionPendingFloats(curr_bfc_offset_.block_offset, &container_builder_,
++ // TODO(ikilpatrick): I think this can be removed.
++ if (IsLegacyBlock(*child) && !is_new_fc) {
++ child_bfc_offset.block_offset += margin_strut.Sum();
++ MaybeUpdateFragmentBfcOffset(
++ ConstraintSpace(), child_bfc_offset.block_offset, &container_builder_);
++ // TODO(ikilpatrick): Check if child_bfc_offset.block_offset is correct -
++ // MaybeUpdateFragmentBfcOffset might have changed it due to clearance.
++ PositionPendingFloats(child_bfc_offset.block_offset, &container_builder_,
+ MutableConstraintSpace());
+- curr_margin_strut_ = {};
++ margin_strut = {};
+ }
+- child_bfc_offset.block_offset = curr_bfc_offset_.block_offset;
+- return child_bfc_offset;
++ return {child_bfc_offset, margin_strut, margins};
+ }
+
+-void NGBlockLayoutAlgorithm::FinishChildLayout(
++NGPreviousInflowPosition NGBlockLayoutAlgorithm::FinishChildLayout(
+ const NGConstraintSpace& child_space,
++ const NGPreviousInflowPosition& previous_inflow_position,
++ const NGInflowChildData& child_data,
+ const NGLayoutInputNode* child,
+ NGLayoutResult* layout_result) {
+ // Pull out unpositioned floats to the current fragment. This may needed if
+@@ -425,97 +458,134 @@ void NGBlockLayoutAlgorithm::FinishChild
+ // Determine the fragment's position in the parent space.
+ WTF::Optional<NGLogicalOffset> child_bfc_offset;
+ if (child_space.IsNewFormattingContext())
+- child_bfc_offset = PositionNewFc(fragment, child_space);
++ child_bfc_offset = PositionNewFc(*child, previous_inflow_position, fragment,
++ child_data, child_space);
+ else if (fragment.BfcOffset())
+ child_bfc_offset = PositionWithBfcOffset(fragment);
+ else if (IsLegacyBlock(*child))
+- child_bfc_offset = PositionLegacy(child_space);
++ child_bfc_offset = PositionLegacy(child_space, child_data);
+ else if (container_builder_.BfcOffset())
+- child_bfc_offset = PositionWithParentBfc(child_space, fragment);
++ child_bfc_offset = PositionWithParentBfc(child_space, child_data, fragment);
+
+- NGLogicalOffset logical_offset = CalculateLogicalOffset(child_bfc_offset);
++ NGLogicalOffset logical_offset =
++ CalculateLogicalOffset(child_data.margins, child_bfc_offset);
+
+- // Update margin strut.
+- curr_margin_strut_ = fragment.EndMarginStrut();
+- curr_margin_strut_.Append(curr_child_margins_.block_end);
++ NGMarginStrut margin_strut = fragment.EndMarginStrut();
++ margin_strut.Append(child_data.margins.block_end);
+
+- // Only modify content_size if BlockSize is not empty. It's needed to prevent
+- // the situation when logical_offset is included in content_size for empty
+- // blocks. Example:
++ // Only modify content_size_ if the fragment's BlockSize is not empty. This is
++ // needed to prevent the situation when logical_offset is included in
++ // content_size_ for empty blocks. Example:
+ // <div style="overflow:hidden">
+ // <div style="margin-top: 8px"></div>
+ // <div style="margin-top: 10px"></div>
+ // </div>
+ if (fragment.BlockSize())
+- content_size_ = fragment.BlockSize() + logical_offset.block_offset;
+- max_inline_size_ =
+- std::max(max_inline_size_, fragment.InlineSize() +
+- curr_child_margins_.InlineSum() +
+- border_and_padding_.InlineSum());
++ content_size_ = std::max(
++ content_size_, logical_offset.block_offset + fragment.BlockSize());
++ max_inline_size_ = std::max(
++ max_inline_size_, fragment.InlineSize() + child_data.margins.InlineSum() +
++ border_and_padding_.InlineSum());
+
+ container_builder_.AddChild(layout_result, logical_offset);
++
++ // Determine the child's end BFC block offset for the next child to use.
++ LayoutUnit child_end_bfc_block_offset;
++ if (child_bfc_offset) {
++ // TODO(crbug.com/716930): I think the fragment.BfcOffset() condition here
++ // can be removed once we've removed inline splitting.
++ if (fragment.BlockSize() || fragment.BfcOffset()) {
++ child_end_bfc_block_offset =
++ child_bfc_offset.value().block_offset + fragment.BlockSize();
++ } else {
++ DCHECK_EQ(LayoutUnit(), fragment.BlockSize());
++ child_end_bfc_block_offset = previous_inflow_position.bfc_block_offset;
++ }
++ } else {
++ child_end_bfc_block_offset = ConstraintSpace().BfcOffset().block_offset;
++ }
++
++ return {child_end_bfc_block_offset,
++ logical_offset.block_offset + fragment.BlockSize(), margin_strut};
+ }
+
+ NGLogicalOffset NGBlockLayoutAlgorithm::PositionNewFc(
++ const NGLayoutInputNode& child,
++ const NGPreviousInflowPosition& previous_inflow_position,
+ const NGBoxFragment& fragment,
++ const NGInflowChildData& child_data,
+ const NGConstraintSpace& child_space) {
++ const ComputedStyle& child_style = child.Style();
++
++ LayoutUnit child_bfc_offset_estimate =
++ child_data.bfc_offset_estimate.block_offset;
++
+ // 1. Position all pending floats to a temporary space.
+ RefPtr<NGConstraintSpace> tmp_space =
+ NGConstraintSpaceBuilder(&child_space)
+ .SetIsNewFormattingContext(false)
+ .ToConstraintSpace(child_space.WritingMode());
+- PositionFloats(curr_bfc_offset_.block_offset, curr_bfc_offset_.block_offset,
+- curr_bfc_offset_.block_offset,
++ PositionFloats(child_bfc_offset_estimate, child_bfc_offset_estimate,
++ child_bfc_offset_estimate,
+ container_builder_.UnpositionedFloats(), tmp_space.Get());
+
+- NGLogicalOffset origin_offset = curr_bfc_offset_;
+- origin_offset.inline_offset += border_and_padding_.inline_start;
++ NGLogicalOffset origin_offset = {ConstraintSpace().BfcOffset().inline_offset +
++ border_and_padding_.inline_start,
++ child_bfc_offset_estimate};
++ AdjustToClearance(
++ GetClearanceOffset(ConstraintSpace().Exclusions(), child_style.Clear()),
++ &origin_offset);
+
+ // 2. Find an estimated layout opportunity for our fragment.
+ NGLayoutOpportunity opportunity = FindLayoutOpportunityForFragment(
+ tmp_space->Exclusions().get(), child_space.AvailableSize(), origin_offset,
+- curr_child_margins_, fragment.Size());
++ child_data.margins, fragment.Size());
++
++ NGMarginStrut margin_strut = previous_inflow_position.margin_strut;
+
+ // 3. If the found opportunity lies on the same line with our estimated
+ // child's BFC offset then merge fragment's margins with the current
+ // MarginStrut.
+- if (opportunity.offset.block_offset == curr_bfc_offset_.block_offset)
+- curr_margin_strut_.Append(curr_child_margins_.block_start);
+- curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
+- curr_margin_strut_ = {};
++ if (opportunity.offset.block_offset == child_bfc_offset_estimate)
++ margin_strut.Append(child_data.margins.block_start);
++ child_bfc_offset_estimate += margin_strut.Sum();
+
+ // 4. The child's BFC block offset is known here.
+- MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_,
++ MaybeUpdateFragmentBfcOffset(ConstraintSpace(), child_bfc_offset_estimate,
+ &container_builder_);
+- PositionPendingFloats(curr_bfc_offset_.block_offset, &container_builder_,
++ PositionPendingFloats(child_bfc_offset_estimate, &container_builder_,
+ MutableConstraintSpace());
+
+- origin_offset = curr_bfc_offset_;
+- origin_offset.inline_offset += border_and_padding_.inline_start;
++ origin_offset = {ConstraintSpace().BfcOffset().inline_offset +
++ border_and_padding_.inline_start,
++ child_bfc_offset_estimate};
++ AdjustToClearance(
++ GetClearanceOffset(ConstraintSpace().Exclusions(), child_style.Clear()),
++ &origin_offset);
+
+ // 5. Find the final layout opportunity for the fragment after all pending
+ // floats are positioned at the correct BFC block's offset.
+ opportunity = FindLayoutOpportunityForFragment(
+ MutableConstraintSpace()->Exclusions().get(), child_space.AvailableSize(),
+- origin_offset, curr_child_margins_, fragment.Size());
++ origin_offset, child_data.margins, fragment.Size());
+
+- curr_bfc_offset_ = opportunity.offset;
+- return curr_bfc_offset_;
++ return opportunity.offset;
+ }
+
+ NGLogicalOffset NGBlockLayoutAlgorithm::PositionWithBfcOffset(
+ const NGBoxFragment& fragment) {
+ DCHECK(fragment.BfcOffset());
+- curr_bfc_offset_.block_offset = fragment.BfcOffset().value().block_offset;
+- MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_,
++ LayoutUnit bfc_block_offset = fragment.BfcOffset().value().block_offset;
++ MaybeUpdateFragmentBfcOffset(ConstraintSpace(), bfc_block_offset,
+ &container_builder_);
+- PositionPendingFloats(curr_bfc_offset_.block_offset, &container_builder_,
++ PositionPendingFloats(bfc_block_offset, &container_builder_,
+ MutableConstraintSpace());
+ return fragment.BfcOffset().value();
+ }
+
+ NGLogicalOffset NGBlockLayoutAlgorithm::PositionWithParentBfc(
+ const NGConstraintSpace& space,
++ const NGInflowChildData& child_data,
+ const NGBoxFragment& fragment) {
+ // The child must be an in-flow zero-block-size fragment, use its end margin
+ // strut for positioning.
+@@ -523,22 +593,28 @@ NGLogicalOffset NGBlockLayoutAlgorithm::
+ DCHECK_EQ(fragment.BlockSize(), LayoutUnit());
+
+ NGMarginStrut margin_strut = fragment.EndMarginStrut();
+- margin_strut.Append(curr_child_margins_.block_end);
++ margin_strut.Append(child_data.margins.block_end);
+
+- curr_bfc_offset_ +=
+- {border_and_padding_.inline_start + curr_child_margins_.inline_start,
+- margin_strut.Sum()};
+- AdjustToClearance(space.ClearanceOffset(), &curr_bfc_offset_);
+- PositionPendingFloatsFromOffset(
+- curr_bfc_offset_.block_offset, curr_bfc_offset_.block_offset,
+- &container_builder_, MutableConstraintSpace());
+- return curr_bfc_offset_;
++ NGLogicalOffset bfc_offset = {
++ ConstraintSpace().BfcOffset().inline_offset +
++ border_and_padding_.inline_start + child_data.margins.inline_start,
++ child_data.bfc_offset_estimate.block_offset + margin_strut.Sum()};
++ AdjustToClearance(space.ClearanceOffset(), &bfc_offset);
++ PositionPendingFloatsFromOffset(bfc_offset.block_offset,
++ bfc_offset.block_offset, &container_builder_,
++ MutableConstraintSpace());
++ return bfc_offset;
+ }
+
+ NGLogicalOffset NGBlockLayoutAlgorithm::PositionLegacy(
+- const NGConstraintSpace& child_space) {
+- AdjustToClearance(child_space.ClearanceOffset(), &curr_bfc_offset_);
+- return curr_bfc_offset_;
++ const NGConstraintSpace& child_space,
++ const NGInflowChildData& child_data) {
++ NGLogicalOffset bfc_offset = {ConstraintSpace().BfcOffset().inline_offset +
++ border_and_padding_.inline_start +
++ child_data.margins.inline_start,
++ child_data.bfc_offset_estimate.block_offset};
++ AdjustToClearance(child_space.ClearanceOffset(), &bfc_offset);
++ return bfc_offset;
+ }
+
+ void NGBlockLayoutAlgorithm::FinalizeForFragmentation() {
+@@ -609,8 +685,8 @@ NGBoxStrut NGBlockLayoutAlgorithm::Calcu
+ }
+
+ RefPtr<NGConstraintSpace> NGBlockLayoutAlgorithm::CreateConstraintSpaceForChild(
+- const NGLogicalOffset& child_bfc_offset,
+- const NGLayoutInputNode& child) {
++ const NGLayoutInputNode& child,
++ const NGInflowChildData& child_data) {
+ NGConstraintSpaceBuilder space_builder(MutableConstraintSpace());
+ space_builder.SetAvailableSize(child_available_size_)
+ .SetPercentageResolutionSize(child_percentage_size_);
+@@ -618,8 +694,8 @@ RefPtr<NGConstraintSpace> NGBlockLayoutA
+ const ComputedStyle& child_style = child.Style();
+ bool is_new_bfc = IsNewFormattingContextForBlockLevelChild(Style(), child);
+ space_builder.SetIsNewFormattingContext(is_new_bfc)
+- .SetBfcOffset(child_bfc_offset)
+- .SetMarginStrut(curr_margin_strut_);
++ .SetBfcOffset(child_data.bfc_offset_estimate)
++ .SetMarginStrut(child_data.margin_strut);
+
+ if (!is_new_bfc) {
+ space_builder.SetUnpositionedFloats(
+@@ -646,7 +722,7 @@ RefPtr<NGConstraintSpace> NGBlockLayoutA
+ // position in the formatting context, and are able to adjust the
+ // fragmentation line.
+ if (is_new_bfc) {
+- space_available -= child_bfc_offset.block_offset;
++ space_available -= child_data.bfc_offset_estimate.block_offset;
+ }
+ }
+ space_builder.SetFragmentainerSpaceAvailable(space_available);
+diff -up chromium-60.0.3112.90/third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.h.perchild chromium-60.0.3112.90/third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.h
+--- chromium-60.0.3112.90/third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.h.perchild 2017-08-02 18:05:34.000000000 -0400
++++ chromium-60.0.3112.90/third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.h 2017-08-09 13:30:01.000000000 -0400
+@@ -18,10 +18,12 @@ namespace blink {
+
+ class NGConstraintSpace;
+ class NGLayoutResult;
++struct NGInflowChildData;
++struct NGPreviousInflowPosition;
+
+ // Updates the fragment's BFC offset if it's not already set.
+ void MaybeUpdateFragmentBfcOffset(const NGConstraintSpace&,
+- const NGLogicalOffset&,
++ LayoutUnit bfc_block_offset,
+ NGFragmentBuilder* builder);
+
+ // Positions pending floats starting from {@origin_block_offset} and relative
+@@ -52,15 +54,19 @@ class CORE_EXPORT NGBlockLayoutAlgorithm
+
+ // Creates a new constraint space for the current child.
+ RefPtr<NGConstraintSpace> CreateConstraintSpaceForChild(
+- const NGLogicalOffset& child_bfc_offset,
+- const NGLayoutInputNode&);
++ const NGLayoutInputNode& child,
++ const NGInflowChildData& child_data);
+
+ // @return Estimated BFC offset for the "to be layout" child.
+- NGLogicalOffset PrepareChildLayout(NGLayoutInputNode*);
++ NGInflowChildData PrepareChildLayout(const NGPreviousInflowPosition&,
++ NGLayoutInputNode*);
+
+- void FinishChildLayout(const NGConstraintSpace&,
+- const NGLayoutInputNode* child,
+- NGLayoutResult*);
++ NGPreviousInflowPosition FinishChildLayout(
++ const NGConstraintSpace&,
++ const NGPreviousInflowPosition& prev_data,
++ const NGInflowChildData& child_data,
++ const NGLayoutInputNode* child,
++ NGLayoutResult*);
+
+ // Positions the fragment that establishes a new formatting context.
+ //
+@@ -81,7 +87,10 @@ class CORE_EXPORT NGBlockLayoutAlgorithm
+ // then it will be placed there and we collapse its margin.
+ // 2) If #new-fc is too big then we need to clear its position and place it
+ // below #float ignoring its vertical margin.
+- NGLogicalOffset PositionNewFc(const NGBoxFragment&,
++ NGLogicalOffset PositionNewFc(const NGLayoutInputNode& child,
++ const NGPreviousInflowPosition&,
++ const NGBoxFragment&,
++ const NGInflowChildData& child_data,
+ const NGConstraintSpace& child_space);
+
+ // Positions the fragment that knows its BFC offset.
+@@ -95,12 +104,16 @@ class CORE_EXPORT NGBlockLayoutAlgorithm
+ // <div style="padding: 1px">
+ // <div id="empty-div" style="margins: 1px"></div>
+ NGLogicalOffset PositionWithParentBfc(const NGConstraintSpace&,
++ const NGInflowChildData& child_data,
+ const NGBoxFragment&);
+
+- NGLogicalOffset PositionLegacy(const NGConstraintSpace& child_space);
++ NGLogicalOffset PositionLegacy(const NGConstraintSpace& child_space,
++ const NGInflowChildData& child_data);
+
+- void HandleOutOfFlowPositioned(NGBlockNode*);
+- void HandleFloating(NGBlockNode*, NGBlockBreakToken*);
++ void HandleOutOfFlowPositioned(const NGPreviousInflowPosition&, NGBlockNode*);
++ void HandleFloating(const NGPreviousInflowPosition&,
++ NGBlockNode*,
++ NGBlockBreakToken*);
+
+ // Final adjustments before fragment creation. We need to prevent the
+ // fragment from crossing fragmentainer boundaries, and rather create a break
+@@ -112,6 +125,7 @@ class CORE_EXPORT NGBlockLayoutAlgorithm
+ // or {@code known_fragment_offset} if the fragment knows it's offset
+ // @return Fragment's offset relative to the fragment's parent.
+ NGLogicalOffset CalculateLogicalOffset(
++ const NGBoxStrut& child_margins,
+ const WTF::Optional<NGLogicalOffset>& known_fragment_offset);
+
+ NGLogicalSize child_available_size_;
+@@ -120,10 +134,6 @@ class CORE_EXPORT NGBlockLayoutAlgorithm
+ NGBoxStrut border_and_padding_;
+ LayoutUnit content_size_;
+ LayoutUnit max_inline_size_;
+- // MarginStrut for the previous child.
+- NGMarginStrut curr_margin_strut_;
+- NGLogicalOffset curr_bfc_offset_;
+- NGBoxStrut curr_child_margins_;
+ };
+
+ } // namespace blink
diff --git a/chromium.spec b/chromium.spec
index bd1de7e..7cc501e 100644
--- a/chromium.spec
+++ b/chromium.spec
@@ -116,7 +116,7 @@ Name: chromium%{chromium_channel}%{?freeworld:-freeworld}
Name: chromium%{chromium_channel}
%endif
Version: %{majorversion}.0.3112.90
-Release: 1%{?dist}
+Release: 2%{?dist}
Summary: A WebKit (Blink) powered web browser
Url: http://www.chromium.org/Home
License: BSD and LGPLv2+ and ASL 2.0 and IJG and MIT and GPLv2+ and ISC and OpenSSL and (MPLv1.1 or GPLv2 or LGPLv2)
@@ -197,6 +197,9 @@ Patch43: chromium-60.0.3112.78-jpeg-nomangle.patch
Patch44: chromium-60.0.3112.78-gtk2fix.patch
# Do not mangle zlib
Patch45: chromium-60.0.3112.78-no-zlib-mangle.patch
+# Apply this change to work around EPEL7 compiler issues
+# https://chromium.googlesource.com/chromium/src/+/639c840bf93e2934fe6b3f56...
+Patch46: chromium-60.0.3112.90-no-per-child.patch
### Chromium Tests Patches ###
@@ -625,6 +628,9 @@ udev.
%patch43 -p1 -b .nomangle
%patch44 -p1 -b .gtk2fix
%patch45 -p1 -b .nozmangle
+%if 0%{?rhel} == 7
+%patch46 -p1 -b .noperchild
+%endif
### Chromium Tests Patches ###
%patch100 -p1 -b .use_system_opus
@@ -1832,6 +1838,9 @@ getent group chrome-remote-desktop >/dev/null || groupadd -r chrome-remote-deskt
%changelog
+* Wed Aug 9 2017 Tom Callaway <spot(a)fedoraproject.org> 60.0.3112.90-2
+- apply post 60 code commit to get code building on epel7
+
* Fri Aug 4 2017 Tom Callaway <spot(a)fedoraproject.org> 60.0.3112.90-1
- update to 60.0.3112.90
7 years, 3 months
[chromium-libs-media-freeworld] (8 commits) ...Merge 'fedora/master' 5922b5c, 60.0.3112.101-1
by Miro Hrončok
Summary of changes:
bbbf61d... apply upstream commit to work around EPEL7 compiler issues
682675b... try to trick old gcc
97f9897... try different hack
268e0a6... okay, do you like this?
efb66ad... apply more workarounds to force code to compile with epel7
26f11a9... apply more workarounds to force code to compile with epel7
5922b5c... update to 60.0.3112.101, apply upstream fix for cameras whi
4495c94... Merge 'fedora/master' 5922b5c, 60.0.3112.101-1
7 years, 3 months
[vlc/f26] (2 commits) ...Fixup lua content
by Nicolas Chauvet
Summary of changes:
95a68c2... Update snapshot (*)
2d97f33... Fixup lua content (*)
(*) This commit already existed in another branch; no separate mail sent
7 years, 3 months
[vlc] Fixup lua content
by Nicolas Chauvet
commit 2d97f330813309df55bf2ecdab056590accc10b4
Author: Nicolas Chauvet <kwizart(a)gmail.com>
Date: Wed Aug 23 18:40:18 2017 +0200
Fixup lua content
vlc.spec | 1 -
1 file changed, 1 deletion(-)
---
diff --git a/vlc.spec b/vlc.spec
index 6dd9bf8..6f1c6d6 100644
--- a/vlc.spec
+++ b/vlc.spec
@@ -523,7 +523,6 @@ fi || :
%dir %{_libdir}/vlc/
%{_libdir}/vlc/vlc-cache-gen
%{_libdir}/vlc/plugins
-%{_libdir}/vlc/lua
%{_mandir}/man1/vlc*.1*
7 years, 3 months
[smplayer] Update smplayer to 17.8.0
by Sérgio M. Basto
commit ceaefaf34a4d9fab00d915802cd92f5854bd28ce
Author: Sérgio M. Basto <sergio(a)serjux.com>
Date: Wed Aug 23 16:56:00 2017 +0100
Update smplayer to 17.8.0
.gitignore | 1 +
smplayer.spec | 5 ++++-
sources | 2 +-
3 files changed, 6 insertions(+), 2 deletions(-)
---
diff --git a/.gitignore b/.gitignore
index 231c7c3..a4a3009 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,3 +28,4 @@ smtube-16.3.0.tar.bz2
/smtube-17.5.0.tar.bz2
/smplayer-17.6.0.tar.bz2
/smplayer-17.7.0.tar.bz2
+/smplayer-17.8.0.tar.bz2
diff --git a/smplayer.spec b/smplayer.spec
index b229418..fba207d 100644
--- a/smplayer.spec
+++ b/smplayer.spec
@@ -1,5 +1,5 @@
Name: smplayer
-Version: 17.7.0
+Version: 17.8.0
%global smtube_ver 17.5.0
%global smplayer_themes_ver 17.3.0
%global smplayer_skins_ver 15.2.0
@@ -208,6 +208,9 @@ fi
%{_datadir}/smplayer/themes/
%changelog
+* Wed Aug 23 2017 Sérgio Basto <sergio(a)serjux.com> - 17.8.0-1
+- Update smplayer to 17.8.0
+
* Wed Jul 05 2017 Sérgio Basto <sergio(a)serjux.com> - 17.7.0-1
- Update smplayer to 17.7.0
diff --git a/sources b/sources
index c7b5792..19b497d 100644
--- a/sources
+++ b/sources
@@ -1,4 +1,4 @@
-8f0572ecc3fb840a854bad2c2907199f smplayer-17.7.0.tar.bz2
+174c1d1ea7d6b6df88c945bdeb91482e smplayer-17.8.0.tar.bz2
edfc9a47bb302b4af6089b152f815d15 smtube-17.5.0.tar.bz2
33c063c5a80c5b1625f51ddbb7bfd3a1 smplayer-themes-17.3.0.tar.bz2
57e165cf9a95808fafd179e5322b7f15 smplayer-skins-15.2.0.tar.bz2
7 years, 3 months
[vlc] Update snapshot
by Nicolas Chauvet
commit 95a68c2b2cee72be399c8d8978fdd76b784d563e
Author: Nicolas Chauvet <kwizart(a)gmail.com>
Date: Wed Aug 23 13:50:23 2017 +0200
Update snapshot
sources | 2 +-
vlc.spec | 12 ++++++------
2 files changed, 7 insertions(+), 7 deletions(-)
---
diff --git a/sources b/sources
index 0b77aec..c758172 100644
--- a/sources
+++ b/sources
@@ -1 +1 @@
-7f8aed98b53cb513b94681ba1d832f7f vlc-3.0.0-20170717-0244-git.tar.xz
+f8beb4af233ac35a47570871b1e350a4 vlc-3.0.0-20170823-0243-git.tar.xz
diff --git a/vlc.spec b/vlc.spec
index 37ac833..6dd9bf8 100644
--- a/vlc.spec
+++ b/vlc.spec
@@ -1,5 +1,5 @@
-%global vlc_date 20170717
-%global vlc_rc -%{?vlc_date}-0244-git
+%global vlc_date 20170823
+%global vlc_rc -%{?vlc_date}-0243-git
%if 0%{?vlc_rc:1}
%global vlc_url https://nightlies.videolan.org/build/source/
%else
@@ -39,14 +39,13 @@
Summary: The cross-platform open-source multimedia framework, player and server
Name: vlc
Version: 3.0.0
-Release: 0.33%{?vlc_date:.git%{vlc_date}}%{?dist}
+Release: 0.34%{?vlc_date:.git%{vlc_date}}%{?dist}
License: GPLv2+
Group: Applications/Multimedia
URL: http://www.videolan.org
Source0: %{vlc_url}/%{?!vlc_rc:%{version}/}vlc-%{version}%{?vlc_rc}.tar.xz
#https://trac.videolan.org/vlc/ticket/18383
Patch0: 0001-qt-Prefer-XCB-over-Wayland.patch
-Patch1: 0001-Revert-lua-don-t-call-directly-config_GetLibDir.patch
BuildRequires: desktop-file-utils
BuildRequires: libappstream-glib
@@ -157,7 +156,6 @@ BuildRequires: pkgconfig(wayland-protocols)
}
%{?_with_schroedinger:BuildRequires: schroedinger-devel >= 1.0.10}
BuildRequires: sqlite-devel
-BuildRequires: SDL_image-devel
%{?_with_sidplay:BuildRequires: pkgconfig(libsidplay2)}
BuildRequires: speex-devel >= 1.1.5
BuildRequires: taglib-devel
@@ -255,7 +253,6 @@ VLC media player extras modules.
%prep
%setup -q -n %{name}-%{version}%{?vlc_rc:-git}
%patch0 -p1 -b .wl
-%patch1 -p1 -b .lua
%{?_with_bootstrap:
rm aclocal.m4 m4/lib*.m4 m4/lt*.m4 || :
./bootstrap
@@ -554,6 +551,9 @@ fi || :
%changelog
+* Wed Aug 23 2017 Nicolas Chauvet <kwizart(a)gmail.com> - 3.0.0-0.34.git20170823
+- Update snapshot
+
* Mon Jul 31 2017 Nicolas Chauvet <kwizart(a)gmail.com> - 3.0.0-0.33.git20170717
- Fix lua directory search path
7 years, 3 months