Update filter blending to match spec draft.

cc/output/filter_operations.h

 // Copyright 2013 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 CC_OUTPUT_FILTER_OPERATIONS_H_
 #define CC_OUTPUT_FILTER_OPERATIONS_H_
 
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 45 matching lines @@
   }
 
   // If |from| is of the same size as this, where in each position, the filter
   // in |from| is of the same type as the filter in this, returns a
   // FilterOperations formed by linearly interpolating at each position a
   // |progress| fraction of the way from the filter in |from|
   // to the filter in this. If either |from| or this is an empty sequence,
   // it is treated as a sequence of the same length as the other sequence,
   // where the filter at each position is a no-op filter of the same type
   // as the filter in that position in the other sequence. Otherwise, if
-  // both |from| and this are non-empty sequences but are either of different
-  // lengths or if there is a type mismatch at some position, returns a copy
-  // of this.
+  // both |from| and this are non-empty sequences but either contains a
+  // reference filter, are either of different lengths without a common prefix

[ajuma, 2013/11/11 18:39:41]

The condition is stronger than "common prefix" (since, e.g. {blur, drop shadow},
{blur, sepia} do have a common prefix, but we can't blend them). It might be
easier to re-write the entire comment than just re-writing the last sentence.
Here's an attempt at doing that:
"If |from| is of the same size as this, where in each position, the filter in
|from| is of the same type as the filter in this, and if this doesn't contain
any reference filters, returns a FilterOperations formed by linearly
interpolating at each position a |progress| fraction of the way from the filter
in |from| to the filter in this. If |from| and this are of different lengths,
they are treated as having the same length by padding the shorter sequence with
no-op filters of the same type as the filters in the corresponding positions in
the longer sequence. If either sequence has a reference filter or if there is a
type mismatch at some position, returns a copy of this." WDYT?

[avallee, 2013/11/12 20:18:09]

SGTM

+  // or if there is a type mismatch at some position, returns a copy of this.
   FilterOperations Blend(const FilterOperations& from, double progress) const;
 
+

[danakj, 2013/11/11 17:59:57]

remove extra whitespace

[avallee, 2013/11/12 20:18:09]

Done.

   scoped_ptr<base::Value> AsValue() const;
 
  private:
+  // Blend helper which blends operations of different sizes. If the shortest
+  // of |from| and this doesn't match the order and type of operations, returns
+  // this.  Otherwise, blends the matching operations from the shorter list and
+  // blends the remaining filters from the longer list with their no-op
+  // equivalents.
+  FilterOperations BlendRaggedOperations(const FilterOperations& from,
+                                         double progress) const;
+
   std::vector<FilterOperation> operations_;
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_FILTER_OPERATIONS_H_