Early return when the value of test-justify is distribute, and the length of line is 0

Source/platform/fonts/Character.cpp

 /*
  * Copyright (C) 2014 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 323 matching lines @@
         0x1F150, 0x1F169,
         0x1F170, 0x1F189,
         0x1F200, 0x1F6FF
     };
 
     return valueInIntervalList(cjkSymbolRanges, c);
 }
 
 unsigned Character::expansionOpportunityCount(const LChar* characters, size_t length, TextDirection direction, bool& isAfterExpansion, const TextJustify textJustify)
 {
+    if (length == 0) {
+        isAfterExpansion = false;

[kojii, 2014/12/05 06:23:22]

Why do we need to set |isAfterExpansion = false| here? The code before your last
change, and the code for UChar, both do not change |isAfterExpansion| and
returns 0 if length == 0, so this line is changing the behavior of this
function.

[dw.im, 2014/12/05 07:16:42]

Because the caller use this value after getting result.
If isAfterExpansion is true, then it is considered as there is one space at the
end of the line so that it will reduce the expansion opportunity because no need
to expand the space at the end of the line.

[kojii, 2014/12/05 13:11:21]

The |isAfterExpansion| is in-out parameter, not out-only. The caller of this
function is responsible to initialize before the call, this function updates the
value, and then the caller can pass the returned value on subsequent calls.
Please refer to an example in RenderBlockLineLayout.cpp:

https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

It initializes |isAfterExpansion| to |true|, then call
|expansionOpportunityCount()| repeatedly on BidiRun's until it reaches to the
end. With this change, it will calculate wrong expansions if there were an empty
run.

You could also check this function before your last patch, or the UChar version
below; both do not change |isAfterExpansion| if |length| is 0.

+        return 0;
+    }
+
     unsigned count = 0;
     if (textJustify == TextJustifyDistribute) {
         count = length - 1;
     } else {
         if (direction == LTR) {
             for (size_t i = 0; i < length; ++i) {
                 if (treatAsSpace(characters[i]))
                     count++;
             }
         } else {
             for (size_t i = length; i > 0; --i) {
                 if (treatAsSpace(characters[i - 1]))
                     count++;
             }
         }
     }
-    int lastCharacter = (direction == LTR) ? length - 1 : 0;
+    size_t lastCharacter = (direction == LTR) ? length - 1 : 0;
     isAfterExpansion = treatAsSpace(characters[lastCharacter]);
 
     return count;
 }
 
 unsigned Character::expansionOpportunityCount(const UChar* characters, size_t length, TextDirection direction, bool& isAfterExpansion, const TextJustify textJustify)
 {
     unsigned count = 0;
     if (direction == LTR) {
         for (size_t i = 0; i < length; ++i) {
@@ skipping 57 matching lines @@
 {
     return normalizeSpacesInternal(characters, length);
 }
 
 String Character::normalizeSpaces(const UChar* characters, unsigned length)
 {
     return normalizeSpacesInternal(characters, length);
 }
 
 } // namespace blink