s/ passed(...) / WTF::passed(...) / to avoid future ambiguity w/ base::Passed.

Explicit WTF:: qualifier for passed, unretained, wrapUnique and makeUnique.

The functions listed in the title of the CL description exist both in
WTF:: and in base:: namespaces and differ only by the case (uppercase vs
lowercase) of the first character in their identifiers.  This will lead
to compile errors after renaming the WTF functions to follow Chromium
style (PascalCaseFunctionNames) because of |using| statements that today
enable the WTF functions to be used without namespace qualification -
such usage will be ambiguous after the rename.  Example:

    ../../third_party/WebKit/Source/platform/WaitableEvent.cpp:17:11:
    error: call to 'WrapUnique' is ambiguous
      impl_ = WrapUnique(new base::WaitableEvent(
              ^~~~~~~~~~
    ../../base/memory/ptr_util.h:17:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
    ../../third_party/WebKit/Source/wtf/PtrUtil.h:16:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
This CL
1) adds WTF:: namespace qualifier to all calls to the affected WTF
   functions
2) removes |using| statements that import the affected WTF functions
   into the global namespace

The second change means that failure to namespace-qualify a call will be
a compile error (e.g. error: use of undeclared identifier 'WrapUnique')
when the argument doesn't come from base or WTF namespace (preventing
reoccurence of the problem in these cases).  When the argument comes
from base or WTF namespace, then ADL will pick the function from the
corresponding namespace.

The Google C++ Style Guide allows using type aliases (including |using
other_namespace::Foo|), although it also says to prefer placing
nonmember functions in a namespace and to use completely global
functions rarely.  The guide also explicitly says "You may not use a
using-directive to make all names from a namespace available" - this is
not what WTF is doing here, but I guess one could argue that all the
individual |using WTF::foo| declarations taken together are not that
different from just doing |using namespace WTF|.  FWIW, I don't see
(grepping for 'using.*base') any |using| statement in a header file
under //base that would pull a name from base:: into the global
namespace (except using base::PathService which is there for legacy
reasons).  References:
- https://google.github.io/styleguide/cppguide.html#Aliases
- https://google.github.io/styleguide/cppguide.html#Namespaces
- https://google.github.io/styleguide/cppguide.html#Nonmember,_Static_Member,_and_Global_Functions

This CL was generated in a fairly mechanical way:
- Run the following under third_party/WebKit/Source for (passed,
  unretained, wrapUnique):
  $ ag '\bpassed\b\(' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bpassed\b(/\1WTF::passed(/g' -i
- Run the following under third_party/WebKit/Source (for makeUnique):
  $ ag '\bmakeUnique' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bmakeUnique<\(.*\)>(/\1WTF::makeUnique<\2>(/g' -i
- Manually remove |using WTF::foo| declarations.
- Manually fixup function definitions (where no WTF:: qualifier should
  be used).
- git cl format
- Manually fix formatting inside comments.
- Do a self-review.

Affected functions:
- third_party/WebKit/Source/wtf/PtrUtil.h:
  - WTF::wrapUnique / base::WrapUnique
  - WTF::makeUnique / base::MakeUnique
- third_party/WebKit/Source/wtf/Functional.h:
  - WTF::passed / base::Passed
  - WTF::unretained / base::Unretained

Note that there are a lot more using statements under WTF that can
potentially conflict with things from other namespaces.  This CL tweaks
only names that are known to cause compile failures after the automatic
rename from blinkStyleFunctions into ChromiumStyleFunctions.  In
particular, the following things are not tweaked by this CL:
- wtf/ASCIICType.h (e.g. WTF::isASCIILower function)
- wtf/AutoReset.h (WTF::AutoReset class)
- wtf/text/Base64.h (e.g. WTF::base64Encode function)
- wtf/Time.h (e.g. WTF::TimeDelta class)

BUG=670908
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2

Committed: https://crrev.com/9d858647530db2c22e1267e443034d23f2e602d9
Cr-Commit-Position: refs/heads/master@{#437358}

[Łukasz Anforowicz, 2016-12-03 00:47:26]

lukasza@chromium.org changed reviewers:
+ tkent@chromium.org

[Łukasz Anforowicz, 2016-12-03 00:47:27]

tkent@, could you PTAL?

[Łukasz Anforowicz, 2016-12-03 01:06:03]

Actually, I think I published this CL too soon:

- I probably should take care of WTF::unretained, WTF::wrapUnique,
WTF::makeUnique, etc. in the same CL

- I probably should also remove |using WTF::passed|, to make sure that the WTF
qualification is not optional going forward (well, at least outside of the WTF
namespace).

I'll update this CL on Monday and ping you again when it is ready for the
review.

Sorry about the fuss.

[haraken, 2016-12-05 01:15:55]

haraken@chromium.org changed reviewers:
+ haraken@chromium.org, yutak@chromium.org

[haraken, 2016-12-05 01:15:56]

I'm just curious but what happens if people forget to add the WTF:: namespace?
Will it hit a compile error? Or will it end up with just using base::
equivalents?

[Yuta Kitamura, 2016-12-05 07:06:26]

On 2016/12/05 01:15:56, haraken wrote:
> I'm just curious but what happens if people forget to add the WTF:: namespace?
> Will it hit a compile error? Or will it end up with just using base::
> equivalents?

I think that will be a compile error (due to ambiguous name).

[Łukasz Anforowicz, 2016-12-05 19:44:17]

Description was changed from

==========
s/ passed(...) / WTF::passed(...) / to avoid future ambiguity w/ base::Passed.

After automated rename of Blink functions into Chromium style (tracked
by https://crbug.com/578344) WTF::passed will become ambiguous wrt
base::Pased, unless references to WTF::passed are namespace-qualified.

This namespace prevents the future ambiguity by adding WTF:: namespace
qualifier to every reference to WTF::passed.

BUG=670908
==========

to

==========
s/ passed(...) / WTF::passed(...) / to avoid future ambiguity w/ base::Passed.

After automated rename of Blink functions into Chromium style (tracked
by https://crbug.com/578344) WTF::passed will become ambiguous wrt
base::Pased, unless references to WTF::passed are namespace-qualified.

This namespace prevents the future ambiguity by adding WTF:: namespace
qualifier to every reference to WTF::passed.

BUG=670908
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
==========

[Łukasz Anforowicz, 2016-12-05 19:44:17]

Description was changed from

==========
s/ passed(...) / WTF::passed(...) / to avoid future ambiguity w/ base::Passed.

After automated rename of Blink functions into Chromium style (tracked
by https://crbug.com/578344) WTF::passed will become ambiguous wrt
base::Pased, unless references to WTF::passed are namespace-qualified.

This namespace prevents the future ambiguity by adding WTF:: namespace
qualifier to every reference to WTF::passed.

BUG=670908
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
==========

to

==========
s/ passed(...) / WTF::passed(...) / to avoid future ambiguity w/ base::Passed.

After automated rename of Blink functions into Chromium style (tracked
by https://crbug.com/578344) WTF::passed will become ambiguous wrt
base::Pased, unless references to WTF::passed are namespace-qualified.

This namespace prevents the future ambiguity by adding WTF:: namespace
qualifier to every reference to WTF::passed.

BUG=670908
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
==========

[Łukasz Anforowicz, 2016-12-05 19:46:31]

On 2016/12/05 07:06:26, Yuta Kitamura wrote:
> On 2016/12/05 01:15:56, haraken wrote:
> > I'm just curious but what happens if people forget to add the WTF::
namespace?
> > Will it hit a compile error? Or will it end up with just using base::
> > equivalents?
> 
> I think that will be a compile error (due to ambiguous name).

It turns out that this is tricky.  I thought that if I change wrapUnique to
WrapUnique (no namespace qualification) in
third_party/WebKit/Source/platform/WaitableEvent.cpp, then it will fail to
compile, but it turns out that it compiles just fine and picks up WrapUnique
from //base.  dcheng@ tells me this is because of
http://en.cppreference.com/w/cpp/language/adl.  ADL almost means that this CL
could just remove |using WTF::foo| and not make any other changes, but WTF::
namespace qualifier is still needed in case the argument is from blink:: (and
not WTF::) namespace.  Below I am trying to give a summary of what should happen
after this CL + after the big rename:
- Unqualified WrapUnique(argumentFromBaseNamespace) - will resolve to
base::WrapUnique
- Unqualified WrapUnique(argumentFromWtfNamespace) - will resolve to
wtf::WrapUnique
- Unqualified WrapUnique(argumentFromBlinkOrStdOrOtherNamespace) - will fail to
compile: error: use of undeclared identifier 'WrapUnique'

The above means that it might not be immediately obvious whether
base::WrapUnique or WTF::WrapUnique is used if a callsite doesn't use a
namespace qualifier.  I think this should still be fine - all base::Foo and
WTF::foo pairs that are touched by the CL under review are almost identical. 
The only difference AFAICT is that the WTF versions have extra static asserts
(e.g. WTF::wrapUnique has a static, compile-time assert the T is not a garbage
collected type).  These static asserts shouldn't matter for cases when ADL picks
up WrapUnique from //base (since no //base type is garbage-collected).  In other
words - the function picked by ADL is arguably the right one to use.

[Łukasz Anforowicz, 2016-12-05 19:51:33]

Description was changed from

==========
s/ passed(...) / WTF::passed(...) / to avoid future ambiguity w/ base::Passed.

After automated rename of Blink functions into Chromium style (tracked
by https://crbug.com/578344) WTF::passed will become ambiguous wrt
base::Pased, unless references to WTF::passed are namespace-qualified.

This namespace prevents the future ambiguity by adding WTF:: namespace
qualifier to every reference to WTF::passed.

BUG=670908
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
==========

to

==========
Explicit WTF:: qualifier for passed, unretained, wrapUnique and makeUnique.

The functions listed in the title of the CL description exist both in
WTF:: and in base:: namespaces and differ only by the case (uppercase vs
lowercase) of the first character in their identifiers.  This will lead
to compile errors after renaming the WTF functions to follow Chromium
style (PascalCaseFunctionNames) because of |using| statements that today
enable the WTF functions to be used without namespace qualification -
such usage will be ambiguous after the rename.  Example:

    ../../third_party/WebKit/Source/platform/WaitableEvent.cpp:17:11:
    error: call to 'WrapUnique' is ambiguous
      impl_ = WrapUnique(new base::WaitableEvent(
              ^~~~~~~~~~
    ../../base/memory/ptr_util.h:17:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
    ../../third_party/WebKit/Source/wtf/PtrUtil.h:16:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
This CL
1) adds WTF:: namespace qualifier to all calls to the affected WTF
   functions
2) removes |using| statements that import the affected WTF functions
   into the global namespace

The second change means that failure to namespace-qualify a call
TODO - FINISH REWRITING THE CL DESCRIPTION
prevents reoccurence of the problem - if one tries to
refer to the function without a namespace qualification, the code will
fail to build (this is true for functions both from WTF and from base
namespace).

The Google C++ Style Guide allows using type aliases (including |using
other_namespace::Foo|), although it also says to prefer placing
nonmember functions in a namespace and to use completely global
functions rarely.  The guide also explicitly says "You may not use a
using-directive to make all names from a namespace available" - this is
not what WTF is doing here, but I guess one could argue that all the
|using WTF::foo| declarations taken together are not that different from
just doing |using namespace WTF|.  FWIW, I don't see (grepping for
'using.*base') any |using| statement in a header file under //base that
would pull a name from base:: into the global namespace (except using
base::PathService which is there for legacy reasons).  References:
- https://google.github.io/styleguide/cppguide.html#Aliases
- https://google.github.io/styleguide/cppguide.html#Namespaces
-
https://google.github.io/styleguide/cppguide.html#Nonmember,_Static_Member,_a...

Affected functions:
- third_party/WebKit/Source/wtf/PtrUtil.h:
  - WTF::wrapUnique / base::WrapUnique
  - WTF::makeUnique / base::MakeUnique
- third_party/WebKit/Source/wtf/Functional.h:
  - WTF::passed / base::Passed
  - WTF::unretained / base::Unretained

Note that there are a lot more using statements under WTF that can
potentially conflict with things from other namespaces.  This CL tweaks
only names that are known to cause compile failures after the automatic
rename from blinkStyleFunctions into ChromiumStyleFunctions.  In
particular, the following things are not tweaked by this CL:
- wtf/ASCIICType.h (e.g. WTF::isASCIILower function)
- wtf/AutoReset.h (WTF::AutoReset class)
- wtf/text/Base64.h (e.g. WTF::base64Encode function)
- wtf/Time.h (e.g. WTF::TimeDelta class)

This CL was generated in a fairly mechanical way:
- Run the following under third_party/WebKit/Source for (passed,
  unretained, wrapUnique):
  $ ag '\bpassed\b\(' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bpassed\b(/\1WTF::passed(/g' -i
- Run the following under third_party/WebKit/Source (for makeUnique):
  $ ag '\bmakeUnique' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bmakeUnique<\(.*\)>(/\1WTF::makeUnique<\2>(/g' -i
- Manually remove |using WTF::foo| declarations.
- Manually fixup function definitions (where no WTF:: qualifier should
  be used).
- git cl format
- Manually fix formatting inside comments.
- Do a self-review.

BUG=670908
==========

[Łukasz Anforowicz, 2016-12-05 20:31:11]

Description was changed from

==========
Explicit WTF:: qualifier for passed, unretained, wrapUnique and makeUnique.

The functions listed in the title of the CL description exist both in
WTF:: and in base:: namespaces and differ only by the case (uppercase vs
lowercase) of the first character in their identifiers.  This will lead
to compile errors after renaming the WTF functions to follow Chromium
style (PascalCaseFunctionNames) because of |using| statements that today
enable the WTF functions to be used without namespace qualification -
such usage will be ambiguous after the rename.  Example:

    ../../third_party/WebKit/Source/platform/WaitableEvent.cpp:17:11:
    error: call to 'WrapUnique' is ambiguous
      impl_ = WrapUnique(new base::WaitableEvent(
              ^~~~~~~~~~
    ../../base/memory/ptr_util.h:17:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
    ../../third_party/WebKit/Source/wtf/PtrUtil.h:16:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
This CL
1) adds WTF:: namespace qualifier to all calls to the affected WTF
   functions
2) removes |using| statements that import the affected WTF functions
   into the global namespace

The second change means that failure to namespace-qualify a call
TODO - FINISH REWRITING THE CL DESCRIPTION
prevents reoccurence of the problem - if one tries to
refer to the function without a namespace qualification, the code will
fail to build (this is true for functions both from WTF and from base
namespace).

The Google C++ Style Guide allows using type aliases (including |using
other_namespace::Foo|), although it also says to prefer placing
nonmember functions in a namespace and to use completely global
functions rarely.  The guide also explicitly says "You may not use a
using-directive to make all names from a namespace available" - this is
not what WTF is doing here, but I guess one could argue that all the
|using WTF::foo| declarations taken together are not that different from
just doing |using namespace WTF|.  FWIW, I don't see (grepping for
'using.*base') any |using| statement in a header file under //base that
would pull a name from base:: into the global namespace (except using
base::PathService which is there for legacy reasons).  References:
- https://google.github.io/styleguide/cppguide.html#Aliases
- https://google.github.io/styleguide/cppguide.html#Namespaces
-
https://google.github.io/styleguide/cppguide.html#Nonmember,_Static_Member,_a...

Affected functions:
- third_party/WebKit/Source/wtf/PtrUtil.h:
  - WTF::wrapUnique / base::WrapUnique
  - WTF::makeUnique / base::MakeUnique
- third_party/WebKit/Source/wtf/Functional.h:
  - WTF::passed / base::Passed
  - WTF::unretained / base::Unretained

Note that there are a lot more using statements under WTF that can
potentially conflict with things from other namespaces.  This CL tweaks
only names that are known to cause compile failures after the automatic
rename from blinkStyleFunctions into ChromiumStyleFunctions.  In
particular, the following things are not tweaked by this CL:
- wtf/ASCIICType.h (e.g. WTF::isASCIILower function)
- wtf/AutoReset.h (WTF::AutoReset class)
- wtf/text/Base64.h (e.g. WTF::base64Encode function)
- wtf/Time.h (e.g. WTF::TimeDelta class)

This CL was generated in a fairly mechanical way:
- Run the following under third_party/WebKit/Source for (passed,
  unretained, wrapUnique):
  $ ag '\bpassed\b\(' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bpassed\b(/\1WTF::passed(/g' -i
- Run the following under third_party/WebKit/Source (for makeUnique):
  $ ag '\bmakeUnique' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bmakeUnique<\(.*\)>(/\1WTF::makeUnique<\2>(/g' -i
- Manually remove |using WTF::foo| declarations.
- Manually fixup function definitions (where no WTF:: qualifier should
  be used).
- git cl format
- Manually fix formatting inside comments.
- Do a self-review.

BUG=670908
==========

to

==========
Explicit WTF:: qualifier for passed, unretained, wrapUnique and makeUnique.

The functions listed in the title of the CL description exist both in
WTF:: and in base:: namespaces and differ only by the case (uppercase vs
lowercase) of the first character in their identifiers.  This will lead
to compile errors after renaming the WTF functions to follow Chromium
style (PascalCaseFunctionNames) because of |using| statements that today
enable the WTF functions to be used without namespace qualification -
such usage will be ambiguous after the rename.  Example:

    ../../third_party/WebKit/Source/platform/WaitableEvent.cpp:17:11:
    error: call to 'WrapUnique' is ambiguous
      impl_ = WrapUnique(new base::WaitableEvent(
              ^~~~~~~~~~
    ../../base/memory/ptr_util.h:17:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
    ../../third_party/WebKit/Source/wtf/PtrUtil.h:16:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
This CL
1) adds WTF:: namespace qualifier to all calls to the affected WTF
   functions
2) removes |using| statements that import the affected WTF functions
   into the global namespace

The second change means that failure to namespace-qualify a call will be
a compile error (e.g. error: use of undeclared identifier 'WrapUnique')
when the argument doesn't come from base or WTF namespace (preventing
reoccurence of the problem in these cases).  When the argument comes
from blink or WTF namespace, then ADL will pick the function from the
corresponding namespace.

The Google C++ Style Guide allows using type aliases (including |using
other_namespace::Foo|), although it also says to prefer placing
nonmember functions in a namespace and to use completely global
functions rarely.  The guide also explicitly says "You may not use a
using-directive to make all names from a namespace available" - this is
not what WTF is doing here, but I guess one could argue that all the
individual |using WTF::foo| declarations taken together are not that
different from just doing |using namespace WTF|.  FWIW, I don't see
(grepping for 'using.*base') any |using| statement in a header file
under //base that would pull a name from base:: into the global
namespace (except using base::PathService which is there for legacy
reasons).  References:
- https://google.github.io/styleguide/cppguide.html#Aliases
- https://google.github.io/styleguide/cppguide.html#Namespaces
-
https://google.github.io/styleguide/cppguide.html#Nonmember,_Static_Member,_a...

This CL was generated in a fairly mechanical way:
- Run the following under third_party/WebKit/Source for (passed,
  unretained, wrapUnique):
  $ ag '\bpassed\b\(' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bpassed\b(/\1WTF::passed(/g' -i
- Run the following under third_party/WebKit/Source (for makeUnique):
  $ ag '\bmakeUnique' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bmakeUnique<\(.*\)>(/\1WTF::makeUnique<\2>(/g' -i
- Manually remove |using WTF::foo| declarations.
- Manually fixup function definitions (where no WTF:: qualifier should
  be used).
- git cl format
- Manually fix formatting inside comments.
- Do a self-review.

Affected functions:
- third_party/WebKit/Source/wtf/PtrUtil.h:
  - WTF::wrapUnique / base::WrapUnique
  - WTF::makeUnique / base::MakeUnique
- third_party/WebKit/Source/wtf/Functional.h:
  - WTF::passed / base::Passed
  - WTF::unretained / base::Unretained

Note that there are a lot more using statements under WTF that can
potentially conflict with things from other namespaces.  This CL tweaks
only names that are known to cause compile failures after the automatic
rename from blinkStyleFunctions into ChromiumStyleFunctions.  In
particular, the following things are not tweaked by this CL:
- wtf/ASCIICType.h (e.g. WTF::isASCIILower function)
- wtf/AutoReset.h (WTF::AutoReset class)
- wtf/text/Base64.h (e.g. WTF::base64Encode function)
- wtf/Time.h (e.g. WTF::TimeDelta class)

BUG=670908
==========

[Łukasz Anforowicz, 2016-12-05 20:47:33]

Description was changed from

==========
Explicit WTF:: qualifier for passed, unretained, wrapUnique and makeUnique.

The functions listed in the title of the CL description exist both in
WTF:: and in base:: namespaces and differ only by the case (uppercase vs
lowercase) of the first character in their identifiers.  This will lead
to compile errors after renaming the WTF functions to follow Chromium
style (PascalCaseFunctionNames) because of |using| statements that today
enable the WTF functions to be used without namespace qualification -
such usage will be ambiguous after the rename.  Example:

    ../../third_party/WebKit/Source/platform/WaitableEvent.cpp:17:11:
    error: call to 'WrapUnique' is ambiguous
      impl_ = WrapUnique(new base::WaitableEvent(
              ^~~~~~~~~~
    ../../base/memory/ptr_util.h:17:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
    ../../third_party/WebKit/Source/wtf/PtrUtil.h:16:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
This CL
1) adds WTF:: namespace qualifier to all calls to the affected WTF
   functions
2) removes |using| statements that import the affected WTF functions
   into the global namespace

The second change means that failure to namespace-qualify a call will be
a compile error (e.g. error: use of undeclared identifier 'WrapUnique')
when the argument doesn't come from base or WTF namespace (preventing
reoccurence of the problem in these cases).  When the argument comes
from blink or WTF namespace, then ADL will pick the function from the
corresponding namespace.

The Google C++ Style Guide allows using type aliases (including |using
other_namespace::Foo|), although it also says to prefer placing
nonmember functions in a namespace and to use completely global
functions rarely.  The guide also explicitly says "You may not use a
using-directive to make all names from a namespace available" - this is
not what WTF is doing here, but I guess one could argue that all the
individual |using WTF::foo| declarations taken together are not that
different from just doing |using namespace WTF|.  FWIW, I don't see
(grepping for 'using.*base') any |using| statement in a header file
under //base that would pull a name from base:: into the global
namespace (except using base::PathService which is there for legacy
reasons).  References:
- https://google.github.io/styleguide/cppguide.html#Aliases
- https://google.github.io/styleguide/cppguide.html#Namespaces
-
https://google.github.io/styleguide/cppguide.html#Nonmember,_Static_Member,_a...

This CL was generated in a fairly mechanical way:
- Run the following under third_party/WebKit/Source for (passed,
  unretained, wrapUnique):
  $ ag '\bpassed\b\(' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bpassed\b(/\1WTF::passed(/g' -i
- Run the following under third_party/WebKit/Source (for makeUnique):
  $ ag '\bmakeUnique' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bmakeUnique<\(.*\)>(/\1WTF::makeUnique<\2>(/g' -i
- Manually remove |using WTF::foo| declarations.
- Manually fixup function definitions (where no WTF:: qualifier should
  be used).
- git cl format
- Manually fix formatting inside comments.
- Do a self-review.

Affected functions:
- third_party/WebKit/Source/wtf/PtrUtil.h:
  - WTF::wrapUnique / base::WrapUnique
  - WTF::makeUnique / base::MakeUnique
- third_party/WebKit/Source/wtf/Functional.h:
  - WTF::passed / base::Passed
  - WTF::unretained / base::Unretained

Note that there are a lot more using statements under WTF that can
potentially conflict with things from other namespaces.  This CL tweaks
only names that are known to cause compile failures after the automatic
rename from blinkStyleFunctions into ChromiumStyleFunctions.  In
particular, the following things are not tweaked by this CL:
- wtf/ASCIICType.h (e.g. WTF::isASCIILower function)
- wtf/AutoReset.h (WTF::AutoReset class)
- wtf/text/Base64.h (e.g. WTF::base64Encode function)
- wtf/Time.h (e.g. WTF::TimeDelta class)

BUG=670908
==========

to

==========
Explicit WTF:: qualifier for passed, unretained, wrapUnique and makeUnique.

The functions listed in the title of the CL description exist both in
WTF:: and in base:: namespaces and differ only by the case (uppercase vs
lowercase) of the first character in their identifiers.  This will lead
to compile errors after renaming the WTF functions to follow Chromium
style (PascalCaseFunctionNames) because of |using| statements that today
enable the WTF functions to be used without namespace qualification -
such usage will be ambiguous after the rename.  Example:

    ../../third_party/WebKit/Source/platform/WaitableEvent.cpp:17:11:
    error: call to 'WrapUnique' is ambiguous
      impl_ = WrapUnique(new base::WaitableEvent(
              ^~~~~~~~~~
    ../../base/memory/ptr_util.h:17:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
    ../../third_party/WebKit/Source/wtf/PtrUtil.h:16:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
This CL
1) adds WTF:: namespace qualifier to all calls to the affected WTF
   functions
2) removes |using| statements that import the affected WTF functions
   into the global namespace

The second change means that failure to namespace-qualify a call will be
a compile error (e.g. error: use of undeclared identifier 'WrapUnique')
when the argument doesn't come from base or WTF namespace (preventing
reoccurence of the problem in these cases).  When the argument comes
from blink or WTF namespace, then ADL will pick the function from the
corresponding namespace.

The Google C++ Style Guide allows using type aliases (including |using
other_namespace::Foo|), although it also says to prefer placing
nonmember functions in a namespace and to use completely global
functions rarely.  The guide also explicitly says "You may not use a
using-directive to make all names from a namespace available" - this is
not what WTF is doing here, but I guess one could argue that all the
individual |using WTF::foo| declarations taken together are not that
different from just doing |using namespace WTF|.  FWIW, I don't see
(grepping for 'using.*base') any |using| statement in a header file
under //base that would pull a name from base:: into the global
namespace (except using base::PathService which is there for legacy
reasons).  References:
- https://google.github.io/styleguide/cppguide.html#Aliases
- https://google.github.io/styleguide/cppguide.html#Namespaces
-
https://google.github.io/styleguide/cppguide.html#Nonmember,_Static_Member,_a...

This CL was generated in a fairly mechanical way:
- Run the following under third_party/WebKit/Source for (passed,
  unretained, wrapUnique):
  $ ag '\bpassed\b\(' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bpassed\b(/\1WTF::passed(/g' -i
- Run the following under third_party/WebKit/Source (for makeUnique):
  $ ag '\bmakeUnique' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bmakeUnique<\(.*\)>(/\1WTF::makeUnique<\2>(/g' -i
- Manually remove |using WTF::foo| declarations.
- Manually fixup function definitions (where no WTF:: qualifier should
  be used).
- git cl format
- Manually fix formatting inside comments.
- Do a self-review.

Affected functions:
- third_party/WebKit/Source/wtf/PtrUtil.h:
  - WTF::wrapUnique / base::WrapUnique
  - WTF::makeUnique / base::MakeUnique
- third_party/WebKit/Source/wtf/Functional.h:
  - WTF::passed / base::Passed
  - WTF::unretained / base::Unretained

Note that there are a lot more using statements under WTF that can
potentially conflict with things from other namespaces.  This CL tweaks
only names that are known to cause compile failures after the automatic
rename from blinkStyleFunctions into ChromiumStyleFunctions.  In
particular, the following things are not tweaked by this CL:
- wtf/ASCIICType.h (e.g. WTF::isASCIILower function)
- wtf/AutoReset.h (WTF::AutoReset class)
- wtf/text/Base64.h (e.g. WTF::base64Encode function)
- wtf/Time.h (e.g. WTF::TimeDelta class)

BUG=670908
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
==========

[Łukasz Anforowicz, 2016-12-05 20:47:34]

Description was changed from

==========
Explicit WTF:: qualifier for passed, unretained, wrapUnique and makeUnique.

The functions listed in the title of the CL description exist both in
WTF:: and in base:: namespaces and differ only by the case (uppercase vs
lowercase) of the first character in their identifiers.  This will lead
to compile errors after renaming the WTF functions to follow Chromium
style (PascalCaseFunctionNames) because of |using| statements that today
enable the WTF functions to be used without namespace qualification -
such usage will be ambiguous after the rename.  Example:

    ../../third_party/WebKit/Source/platform/WaitableEvent.cpp:17:11:
    error: call to 'WrapUnique' is ambiguous
      impl_ = WrapUnique(new base::WaitableEvent(
              ^~~~~~~~~~
    ../../base/memory/ptr_util.h:17:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
    ../../third_party/WebKit/Source/wtf/PtrUtil.h:16:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
This CL
1) adds WTF:: namespace qualifier to all calls to the affected WTF
   functions
2) removes |using| statements that import the affected WTF functions
   into the global namespace

The second change means that failure to namespace-qualify a call will be
a compile error (e.g. error: use of undeclared identifier 'WrapUnique')
when the argument doesn't come from base or WTF namespace (preventing
reoccurence of the problem in these cases).  When the argument comes
from blink or WTF namespace, then ADL will pick the function from the
corresponding namespace.

The Google C++ Style Guide allows using type aliases (including |using
other_namespace::Foo|), although it also says to prefer placing
nonmember functions in a namespace and to use completely global
functions rarely.  The guide also explicitly says "You may not use a
using-directive to make all names from a namespace available" - this is
not what WTF is doing here, but I guess one could argue that all the
individual |using WTF::foo| declarations taken together are not that
different from just doing |using namespace WTF|.  FWIW, I don't see
(grepping for 'using.*base') any |using| statement in a header file
under //base that would pull a name from base:: into the global
namespace (except using base::PathService which is there for legacy
reasons).  References:
- https://google.github.io/styleguide/cppguide.html#Aliases
- https://google.github.io/styleguide/cppguide.html#Namespaces
-
https://google.github.io/styleguide/cppguide.html#Nonmember,_Static_Member,_a...

This CL was generated in a fairly mechanical way:
- Run the following under third_party/WebKit/Source for (passed,
  unretained, wrapUnique):
  $ ag '\bpassed\b\(' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bpassed\b(/\1WTF::passed(/g' -i
- Run the following under third_party/WebKit/Source (for makeUnique):
  $ ag '\bmakeUnique' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bmakeUnique<\(.*\)>(/\1WTF::makeUnique<\2>(/g' -i
- Manually remove |using WTF::foo| declarations.
- Manually fixup function definitions (where no WTF:: qualifier should
  be used).
- git cl format
- Manually fix formatting inside comments.
- Do a self-review.

Affected functions:
- third_party/WebKit/Source/wtf/PtrUtil.h:
  - WTF::wrapUnique / base::WrapUnique
  - WTF::makeUnique / base::MakeUnique
- third_party/WebKit/Source/wtf/Functional.h:
  - WTF::passed / base::Passed
  - WTF::unretained / base::Unretained

Note that there are a lot more using statements under WTF that can
potentially conflict with things from other namespaces.  This CL tweaks
only names that are known to cause compile failures after the automatic
rename from blinkStyleFunctions into ChromiumStyleFunctions.  In
particular, the following things are not tweaked by this CL:
- wtf/ASCIICType.h (e.g. WTF::isASCIILower function)
- wtf/AutoReset.h (WTF::AutoReset class)
- wtf/text/Base64.h (e.g. WTF::base64Encode function)
- wtf/Time.h (e.g. WTF::TimeDelta class)

BUG=670908
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
==========

to

==========
Explicit WTF:: qualifier for passed, unretained, wrapUnique and makeUnique.

The functions listed in the title of the CL description exist both in
WTF:: and in base:: namespaces and differ only by the case (uppercase vs
lowercase) of the first character in their identifiers.  This will lead
to compile errors after renaming the WTF functions to follow Chromium
style (PascalCaseFunctionNames) because of |using| statements that today
enable the WTF functions to be used without namespace qualification -
such usage will be ambiguous after the rename.  Example:

    ../../third_party/WebKit/Source/platform/WaitableEvent.cpp:17:11:
    error: call to 'WrapUnique' is ambiguous
      impl_ = WrapUnique(new base::WaitableEvent(
              ^~~~~~~~~~
    ../../base/memory/ptr_util.h:17:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
    ../../third_party/WebKit/Source/wtf/PtrUtil.h:16:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
This CL
1) adds WTF:: namespace qualifier to all calls to the affected WTF
   functions
2) removes |using| statements that import the affected WTF functions
   into the global namespace

The second change means that failure to namespace-qualify a call will be
a compile error (e.g. error: use of undeclared identifier 'WrapUnique')
when the argument doesn't come from base or WTF namespace (preventing
reoccurence of the problem in these cases).  When the argument comes
from blink or WTF namespace, then ADL will pick the function from the
corresponding namespace.

The Google C++ Style Guide allows using type aliases (including |using
other_namespace::Foo|), although it also says to prefer placing
nonmember functions in a namespace and to use completely global
functions rarely.  The guide also explicitly says "You may not use a
using-directive to make all names from a namespace available" - this is
not what WTF is doing here, but I guess one could argue that all the
individual |using WTF::foo| declarations taken together are not that
different from just doing |using namespace WTF|.  FWIW, I don't see
(grepping for 'using.*base') any |using| statement in a header file
under //base that would pull a name from base:: into the global
namespace (except using base::PathService which is there for legacy
reasons).  References:
- https://google.github.io/styleguide/cppguide.html#Aliases
- https://google.github.io/styleguide/cppguide.html#Namespaces
-
https://google.github.io/styleguide/cppguide.html#Nonmember,_Static_Member,_a...

This CL was generated in a fairly mechanical way:
- Run the following under third_party/WebKit/Source for (passed,
  unretained, wrapUnique):
  $ ag '\bpassed\b\(' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bpassed\b(/\1WTF::passed(/g' -i
- Run the following under third_party/WebKit/Source (for makeUnique):
  $ ag '\bmakeUnique' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bmakeUnique<\(.*\)>(/\1WTF::makeUnique<\2>(/g' -i
- Manually remove |using WTF::foo| declarations.
- Manually fixup function definitions (where no WTF:: qualifier should
  be used).
- git cl format
- Manually fix formatting inside comments.
- Do a self-review.

Affected functions:
- third_party/WebKit/Source/wtf/PtrUtil.h:
  - WTF::wrapUnique / base::WrapUnique
  - WTF::makeUnique / base::MakeUnique
- third_party/WebKit/Source/wtf/Functional.h:
  - WTF::passed / base::Passed
  - WTF::unretained / base::Unretained

Note that there are a lot more using statements under WTF that can
potentially conflict with things from other namespaces.  This CL tweaks
only names that are known to cause compile failures after the automatic
rename from blinkStyleFunctions into ChromiumStyleFunctions.  In
particular, the following things are not tweaked by this CL:
- wtf/ASCIICType.h (e.g. WTF::isASCIILower function)
- wtf/AutoReset.h (WTF::AutoReset class)
- wtf/text/Base64.h (e.g. WTF::base64Encode function)
- wtf/Time.h (e.g. WTF::TimeDelta class)

BUG=670908
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
==========

[tkent, 2016-12-05 23:30:26]

This CL lgtm.

However, IMO we shouldn't have two different implementations of WrapUnique(). 
Can we move assert() in WTF::wrapUnique() to base::WrapUnique(), or can we
implement the assertion in blink-gc clang plugin?

[Łukasz Anforowicz, 2016-12-06 00:25:14]

On 2016/12/05 23:30:26, tkent wrote:
> This CL lgtm.

Thank you for the review.  I just got back to the office and see that all the
bots are green after rebasing, so I was about to ask you for a review - thank
you for proactively taking a look :-)

I'll hold off with pushing this CL to CQ until Tuesday (to give haraken@ [and
other Blink reviewers] a chance to respond if needed).

> However, IMO we shouldn't have two different implementations of WrapUnique(). 
> Can we move assert() in WTF::wrapUnique() to base::WrapUnique(), or can we
> implement the assertion in blink-gc clang plugin?

I agree with the goal of removing code duplication.  I've opened
https://crbug.com/671414 to track this - let's use this bug to discuss possible
approaches and their desirability.

[haraken, 2016-12-06 01:06:02]

This CL LGTM.

On 2016/12/06 00:25:14, Łukasz Anforowicz wrote:
> On 2016/12/05 23:30:26, tkent wrote:
> > This CL lgtm.
> 
> Thank you for the review.  I just got back to the office and see that all the
> bots are green after rebasing, so I was about to ask you for a review - thank
> you for proactively taking a look :-)
> 
> I'll hold off with pushing this CL to CQ until Tuesday (to give haraken@ [and
> other Blink reviewers] a chance to respond if needed).
> 
> > However, IMO we shouldn't have two different implementations of
WrapUnique(). 
> > Can we move assert() in WTF::wrapUnique() to base::WrapUnique(), or can we
> > implement the assertion in blink-gc clang plugin?
> 
> I agree with the goal of removing code duplication.  I've opened
> https://crbug.com/671414 to track this - let's use this bug to discuss
possible
> approaches and their desirability.

It's technically possible to replace the static_assert with the plugin check.
However, as dcheng@ pointed out in
https://bugs.chromium.org/p/chromium/issues/detail?id=671414#c3, static_assert
is much easier to maintain. It takes months to roll the clang plugin and is hard
to cover all type information (even though in theory we can do that).

What's the advantage of removing WTF::wrapUnique, in the first place? We are not
allowed to use base:: types directly in core/ and modules/, so we anyway need to
wrap the base:: types in wtf/.

[Łukasz Anforowicz, 2016-12-06 17:30:04]

The CQ bit was checked by lukasza@chromium.org to run a CQ dry run

[commit-bot: I haz the power, 2016-12-06 17:30:41]

Dry run: CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[commit-bot: I haz the power, 2016-12-06 17:40:06]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2016-12-06 17:40:08]

Dry run: Try jobs failed on following builders:
  android_clang_dbg_recipe on master.tryserver.chromium.android (JOB_FAILED,
https://build.chromium.org/p/tryserver.chromium.android/builders/android_clan...)
  android_compile_dbg on master.tryserver.chromium.android (JOB_FAILED,
https://build.chromium.org/p/tryserver.chromium.android/builders/android_comp...)
  linux_android_rel_ng on master.tryserver.chromium.android (JOB_FAILED,
https://build.chromium.org/p/tryserver.chromium.android/builders/linux_androi...)
  ios-device on master.tryserver.chromium.mac (JOB_FAILED,
http://build.chromium.org/p/tryserver.chromium.mac/builders/ios-device/builds...)

[Łukasz Anforowicz, 2016-12-06 18:07:59]

The CQ bit was checked by lukasza@chromium.org to run a CQ dry run

[commit-bot: I haz the power, 2016-12-06 18:08:36]

Dry run: CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[Łukasz Anforowicz, 2016-12-06 19:10:01]

The CQ bit was unchecked by lukasza@chromium.org

[Łukasz Anforowicz, 2016-12-06 19:10:14]

The CQ bit was checked by lukasza@chromium.org

[Łukasz Anforowicz, 2016-12-06 19:10:16]

The patchset sent to the CQ was uploaded after l-g-t-m from tkent@chromium.org,
haraken@chromium.org
Link to the patchset: https://codereview.chromium.org/2547053003/#ps80001
(title: "Rebasing...")

[commit-bot: I haz the power, 2016-12-06 19:10:53]

CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[commit-bot: I haz the power, 2016-12-06 20:53:17]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2016-12-06 20:53:20]

Try jobs failed on following builders:
  linux_chromium_rel_ng on master.tryserver.chromium.linux (JOB_FAILED,
http://build.chromium.org/p/tryserver.chromium.linux/builders/linux_chromium_...)

[Łukasz Anforowicz, 2016-12-06 21:41:02]

The CQ bit was checked by lukasza@chromium.org

[Łukasz Anforowicz, 2016-12-06 21:41:04]

The patchset sent to the CQ was uploaded after l-g-t-m from tkent@chromium.org,
haraken@chromium.org
Link to the patchset: https://codereview.chromium.org/2547053003/#ps100001
(title: "Rebasing again...")

[commit-bot: I haz the power, 2016-12-06 21:42:01]

CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[Łukasz Anforowicz, 2016-12-06 21:42:50]

The CQ bit was unchecked by lukasza@chromium.org

[Łukasz Anforowicz, 2016-12-06 21:42:51]

The CQ bit was checked by lukasza@chromium.org

[commit-bot: I haz the power, 2016-12-06 21:43:21]

CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[commit-bot: I haz the power, 2016-12-07 00:10:55]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2016-12-07 00:10:58]

Try jobs failed on following builders:
  linux_chromium_rel_ng on master.tryserver.chromium.linux (JOB_FAILED,
http://build.chromium.org/p/tryserver.chromium.linux/builders/linux_chromium_...)

[Łukasz Anforowicz, 2016-12-08 02:41:10]

The CQ bit was checked by lukasza@chromium.org to run a CQ dry run

[commit-bot: I haz the power, 2016-12-08 02:41:43]

Dry run: CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[commit-bot: I haz the power, 2016-12-08 04:37:40]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2016-12-08 04:37:43]

Dry run: Try jobs failed on following builders:
  android_n5x_swarming_rel on master.tryserver.chromium.android (JOB_FAILED,
https://build.chromium.org/p/tryserver.chromium.android/builders/android_n5x_...)

[Łukasz Anforowicz, 2016-12-08 06:02:07]

Description was changed from

==========
Explicit WTF:: qualifier for passed, unretained, wrapUnique and makeUnique.

The functions listed in the title of the CL description exist both in
WTF:: and in base:: namespaces and differ only by the case (uppercase vs
lowercase) of the first character in their identifiers.  This will lead
to compile errors after renaming the WTF functions to follow Chromium
style (PascalCaseFunctionNames) because of |using| statements that today
enable the WTF functions to be used without namespace qualification -
such usage will be ambiguous after the rename.  Example:

    ../../third_party/WebKit/Source/platform/WaitableEvent.cpp:17:11:
    error: call to 'WrapUnique' is ambiguous
      impl_ = WrapUnique(new base::WaitableEvent(
              ^~~~~~~~~~
    ../../base/memory/ptr_util.h:17:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
    ../../third_party/WebKit/Source/wtf/PtrUtil.h:16:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
This CL
1) adds WTF:: namespace qualifier to all calls to the affected WTF
   functions
2) removes |using| statements that import the affected WTF functions
   into the global namespace

The second change means that failure to namespace-qualify a call will be
a compile error (e.g. error: use of undeclared identifier 'WrapUnique')
when the argument doesn't come from base or WTF namespace (preventing
reoccurence of the problem in these cases).  When the argument comes
from blink or WTF namespace, then ADL will pick the function from the
corresponding namespace.

The Google C++ Style Guide allows using type aliases (including |using
other_namespace::Foo|), although it also says to prefer placing
nonmember functions in a namespace and to use completely global
functions rarely.  The guide also explicitly says "You may not use a
using-directive to make all names from a namespace available" - this is
not what WTF is doing here, but I guess one could argue that all the
individual |using WTF::foo| declarations taken together are not that
different from just doing |using namespace WTF|.  FWIW, I don't see
(grepping for 'using.*base') any |using| statement in a header file
under //base that would pull a name from base:: into the global
namespace (except using base::PathService which is there for legacy
reasons).  References:
- https://google.github.io/styleguide/cppguide.html#Aliases
- https://google.github.io/styleguide/cppguide.html#Namespaces
-
https://google.github.io/styleguide/cppguide.html#Nonmember,_Static_Member,_a...

This CL was generated in a fairly mechanical way:
- Run the following under third_party/WebKit/Source for (passed,
  unretained, wrapUnique):
  $ ag '\bpassed\b\(' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bpassed\b(/\1WTF::passed(/g' -i
- Run the following under third_party/WebKit/Source (for makeUnique):
  $ ag '\bmakeUnique' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bmakeUnique<\(.*\)>(/\1WTF::makeUnique<\2>(/g' -i
- Manually remove |using WTF::foo| declarations.
- Manually fixup function definitions (where no WTF:: qualifier should
  be used).
- git cl format
- Manually fix formatting inside comments.
- Do a self-review.

Affected functions:
- third_party/WebKit/Source/wtf/PtrUtil.h:
  - WTF::wrapUnique / base::WrapUnique
  - WTF::makeUnique / base::MakeUnique
- third_party/WebKit/Source/wtf/Functional.h:
  - WTF::passed / base::Passed
  - WTF::unretained / base::Unretained

Note that there are a lot more using statements under WTF that can
potentially conflict with things from other namespaces.  This CL tweaks
only names that are known to cause compile failures after the automatic
rename from blinkStyleFunctions into ChromiumStyleFunctions.  In
particular, the following things are not tweaked by this CL:
- wtf/ASCIICType.h (e.g. WTF::isASCIILower function)
- wtf/AutoReset.h (WTF::AutoReset class)
- wtf/text/Base64.h (e.g. WTF::base64Encode function)
- wtf/Time.h (e.g. WTF::TimeDelta class)

BUG=670908
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
==========

to

==========
Explicit WTF:: qualifier for passed, unretained, wrapUnique and makeUnique.

The functions listed in the title of the CL description exist both in
WTF:: and in base:: namespaces and differ only by the case (uppercase vs
lowercase) of the first character in their identifiers.  This will lead
to compile errors after renaming the WTF functions to follow Chromium
style (PascalCaseFunctionNames) because of |using| statements that today
enable the WTF functions to be used without namespace qualification -
such usage will be ambiguous after the rename.  Example:

    ../../third_party/WebKit/Source/platform/WaitableEvent.cpp:17:11:
    error: call to 'WrapUnique' is ambiguous
      impl_ = WrapUnique(new base::WaitableEvent(
              ^~~~~~~~~~
    ../../base/memory/ptr_util.h:17:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
    ../../third_party/WebKit/Source/wtf/PtrUtil.h:16:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
This CL
1) adds WTF:: namespace qualifier to all calls to the affected WTF
   functions
2) removes |using| statements that import the affected WTF functions
   into the global namespace

The second change means that failure to namespace-qualify a call will be
a compile error (e.g. error: use of undeclared identifier 'WrapUnique')
when the argument doesn't come from base or WTF namespace (preventing
reoccurence of the problem in these cases).  When the argument comes
from base or WTF namespace, then ADL will pick the function from the
corresponding namespace.

The Google C++ Style Guide allows using type aliases (including |using
other_namespace::Foo|), although it also says to prefer placing
nonmember functions in a namespace and to use completely global
functions rarely.  The guide also explicitly says "You may not use a
using-directive to make all names from a namespace available" - this is
not what WTF is doing here, but I guess one could argue that all the
individual |using WTF::foo| declarations taken together are not that
different from just doing |using namespace WTF|.  FWIW, I don't see
(grepping for 'using.*base') any |using| statement in a header file
under //base that would pull a name from base:: into the global
namespace (except using base::PathService which is there for legacy
reasons).  References:
- https://google.github.io/styleguide/cppguide.html#Aliases
- https://google.github.io/styleguide/cppguide.html#Namespaces
-
https://google.github.io/styleguide/cppguide.html#Nonmember,_Static_Member,_a...

This CL was generated in a fairly mechanical way:
- Run the following under third_party/WebKit/Source for (passed,
  unretained, wrapUnique):
  $ ag '\bpassed\b\(' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bpassed\b(/\1WTF::passed(/g' -i
- Run the following under third_party/WebKit/Source (for makeUnique):
  $ ag '\bmakeUnique' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bmakeUnique<\(.*\)>(/\1WTF::makeUnique<\2>(/g' -i
- Manually remove |using WTF::foo| declarations.
- Manually fixup function definitions (where no WTF:: qualifier should
  be used).
- git cl format
- Manually fix formatting inside comments.
- Do a self-review.

Affected functions:
- third_party/WebKit/Source/wtf/PtrUtil.h:
  - WTF::wrapUnique / base::WrapUnique
  - WTF::makeUnique / base::MakeUnique
- third_party/WebKit/Source/wtf/Functional.h:
  - WTF::passed / base::Passed
  - WTF::unretained / base::Unretained

Note that there are a lot more using statements under WTF that can
potentially conflict with things from other namespaces.  This CL tweaks
only names that are known to cause compile failures after the automatic
rename from blinkStyleFunctions into ChromiumStyleFunctions.  In
particular, the following things are not tweaked by this CL:
- wtf/ASCIICType.h (e.g. WTF::isASCIILower function)
- wtf/AutoReset.h (WTF::AutoReset class)
- wtf/text/Base64.h (e.g. WTF::base64Encode function)
- wtf/Time.h (e.g. WTF::TimeDelta class)

BUG=670908
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
==========

[Łukasz Anforowicz, 2016-12-08 14:59:19]

The CQ bit was checked by lukasza@chromium.org

[Łukasz Anforowicz, 2016-12-08 14:59:21]

The patchset sent to the CQ was uploaded after l-g-t-m from tkent@chromium.org,
haraken@chromium.org
Link to the patchset: https://codereview.chromium.org/2547053003/#ps140001
(title: "Rebasing...")

[commit-bot: I haz the power, 2016-12-08 14:59:44]

CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[commit-bot: I haz the power, 2016-12-08 17:06:34]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2016-12-08 17:06:38]

Try jobs failed on following builders:
  android_n5x_swarming_rel on master.tryserver.chromium.android (JOB_FAILED,
https://build.chromium.org/p/tryserver.chromium.android/builders/android_n5x_...)

[Łukasz Anforowicz, 2016-12-08 17:08:16]

The CQ bit was checked by lukasza@chromium.org

[commit-bot: I haz the power, 2016-12-08 17:08:49]

CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[commit-bot: I haz the power, 2016-12-08 19:26:06]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2016-12-08 19:26:10]

Try jobs failed on following builders:
  android_n5x_swarming_rel on master.tryserver.chromium.android (JOB_FAILED,
https://build.chromium.org/p/tryserver.chromium.android/builders/android_n5x_...)

[Łukasz Anforowicz, 2016-12-08 19:43:23]

The CQ bit was checked by lukasza@chromium.org

[commit-bot: I haz the power, 2016-12-08 19:43:57]

CQ is trying da patch. Follow status at
 
https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...

[commit-bot: I haz the power, 2016-12-08 21:52:19]

CQ is committing da patch.

Bot data: {"patchset_id": 140001, "attempt_start_ts": 1481226203964880,
"parent_rev": "7a7714303f8e3f6fa6b66cc92692bdaa823638a5", "commit_rev":
"0823ee7af6ab70d0939f3b6268ea234577b81666"}

[commit-bot: I haz the power, 2016-12-08 21:52:47]

Description was changed from

==========
Explicit WTF:: qualifier for passed, unretained, wrapUnique and makeUnique.

The functions listed in the title of the CL description exist both in
WTF:: and in base:: namespaces and differ only by the case (uppercase vs
lowercase) of the first character in their identifiers.  This will lead
to compile errors after renaming the WTF functions to follow Chromium
style (PascalCaseFunctionNames) because of |using| statements that today
enable the WTF functions to be used without namespace qualification -
such usage will be ambiguous after the rename.  Example:

    ../../third_party/WebKit/Source/platform/WaitableEvent.cpp:17:11:
    error: call to 'WrapUnique' is ambiguous
      impl_ = WrapUnique(new base::WaitableEvent(
              ^~~~~~~~~~
    ../../base/memory/ptr_util.h:17:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
    ../../third_party/WebKit/Source/wtf/PtrUtil.h:16:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
This CL
1) adds WTF:: namespace qualifier to all calls to the affected WTF
   functions
2) removes |using| statements that import the affected WTF functions
   into the global namespace

The second change means that failure to namespace-qualify a call will be
a compile error (e.g. error: use of undeclared identifier 'WrapUnique')
when the argument doesn't come from base or WTF namespace (preventing
reoccurence of the problem in these cases).  When the argument comes
from base or WTF namespace, then ADL will pick the function from the
corresponding namespace.

The Google C++ Style Guide allows using type aliases (including |using
other_namespace::Foo|), although it also says to prefer placing
nonmember functions in a namespace and to use completely global
functions rarely.  The guide also explicitly says "You may not use a
using-directive to make all names from a namespace available" - this is
not what WTF is doing here, but I guess one could argue that all the
individual |using WTF::foo| declarations taken together are not that
different from just doing |using namespace WTF|.  FWIW, I don't see
(grepping for 'using.*base') any |using| statement in a header file
under //base that would pull a name from base:: into the global
namespace (except using base::PathService which is there for legacy
reasons).  References:
- https://google.github.io/styleguide/cppguide.html#Aliases
- https://google.github.io/styleguide/cppguide.html#Namespaces
-
https://google.github.io/styleguide/cppguide.html#Nonmember,_Static_Member,_a...

This CL was generated in a fairly mechanical way:
- Run the following under third_party/WebKit/Source for (passed,
  unretained, wrapUnique):
  $ ag '\bpassed\b\(' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bpassed\b(/\1WTF::passed(/g' -i
- Run the following under third_party/WebKit/Source (for makeUnique):
  $ ag '\bmakeUnique' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bmakeUnique<\(.*\)>(/\1WTF::makeUnique<\2>(/g' -i
- Manually remove |using WTF::foo| declarations.
- Manually fixup function definitions (where no WTF:: qualifier should
  be used).
- git cl format
- Manually fix formatting inside comments.
- Do a self-review.

Affected functions:
- third_party/WebKit/Source/wtf/PtrUtil.h:
  - WTF::wrapUnique / base::WrapUnique
  - WTF::makeUnique / base::MakeUnique
- third_party/WebKit/Source/wtf/Functional.h:
  - WTF::passed / base::Passed
  - WTF::unretained / base::Unretained

Note that there are a lot more using statements under WTF that can
potentially conflict with things from other namespaces.  This CL tweaks
only names that are known to cause compile failures after the automatic
rename from blinkStyleFunctions into ChromiumStyleFunctions.  In
particular, the following things are not tweaked by this CL:
- wtf/ASCIICType.h (e.g. WTF::isASCIILower function)
- wtf/AutoReset.h (WTF::AutoReset class)
- wtf/text/Base64.h (e.g. WTF::base64Encode function)
- wtf/Time.h (e.g. WTF::TimeDelta class)

BUG=670908
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
==========

to

==========
Explicit WTF:: qualifier for passed, unretained, wrapUnique and makeUnique.

The functions listed in the title of the CL description exist both in
WTF:: and in base:: namespaces and differ only by the case (uppercase vs
lowercase) of the first character in their identifiers.  This will lead
to compile errors after renaming the WTF functions to follow Chromium
style (PascalCaseFunctionNames) because of |using| statements that today
enable the WTF functions to be used without namespace qualification -
such usage will be ambiguous after the rename.  Example:

    ../../third_party/WebKit/Source/platform/WaitableEvent.cpp:17:11:
    error: call to 'WrapUnique' is ambiguous
      impl_ = WrapUnique(new base::WaitableEvent(
              ^~~~~~~~~~
    ../../base/memory/ptr_util.h:17:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
    ../../third_party/WebKit/Source/wtf/PtrUtil.h:16:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
This CL
1) adds WTF:: namespace qualifier to all calls to the affected WTF
   functions
2) removes |using| statements that import the affected WTF functions
   into the global namespace

The second change means that failure to namespace-qualify a call will be
a compile error (e.g. error: use of undeclared identifier 'WrapUnique')
when the argument doesn't come from base or WTF namespace (preventing
reoccurence of the problem in these cases).  When the argument comes
from base or WTF namespace, then ADL will pick the function from the
corresponding namespace.

The Google C++ Style Guide allows using type aliases (including |using
other_namespace::Foo|), although it also says to prefer placing
nonmember functions in a namespace and to use completely global
functions rarely.  The guide also explicitly says "You may not use a
using-directive to make all names from a namespace available" - this is
not what WTF is doing here, but I guess one could argue that all the
individual |using WTF::foo| declarations taken together are not that
different from just doing |using namespace WTF|.  FWIW, I don't see
(grepping for 'using.*base') any |using| statement in a header file
under //base that would pull a name from base:: into the global
namespace (except using base::PathService which is there for legacy
reasons).  References:
- https://google.github.io/styleguide/cppguide.html#Aliases
- https://google.github.io/styleguide/cppguide.html#Namespaces
-
https://google.github.io/styleguide/cppguide.html#Nonmember,_Static_Member,_a...

This CL was generated in a fairly mechanical way:
- Run the following under third_party/WebKit/Source for (passed,
  unretained, wrapUnique):
  $ ag '\bpassed\b\(' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bpassed\b(/\1WTF::passed(/g' -i
- Run the following under third_party/WebKit/Source (for makeUnique):
  $ ag '\bmakeUnique' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bmakeUnique<\(.*\)>(/\1WTF::makeUnique<\2>(/g' -i
- Manually remove |using WTF::foo| declarations.
- Manually fixup function definitions (where no WTF:: qualifier should
  be used).
- git cl format
- Manually fix formatting inside comments.
- Do a self-review.

Affected functions:
- third_party/WebKit/Source/wtf/PtrUtil.h:
  - WTF::wrapUnique / base::WrapUnique
  - WTF::makeUnique / base::MakeUnique
- third_party/WebKit/Source/wtf/Functional.h:
  - WTF::passed / base::Passed
  - WTF::unretained / base::Unretained

Note that there are a lot more using statements under WTF that can
potentially conflict with things from other namespaces.  This CL tweaks
only names that are known to cause compile failures after the automatic
rename from blinkStyleFunctions into ChromiumStyleFunctions.  In
particular, the following things are not tweaked by this CL:
- wtf/ASCIICType.h (e.g. WTF::isASCIILower function)
- wtf/AutoReset.h (WTF::AutoReset class)
- wtf/text/Base64.h (e.g. WTF::base64Encode function)
- wtf/Time.h (e.g. WTF::TimeDelta class)

BUG=670908
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
==========

[commit-bot: I haz the power, 2016-12-08 21:52:50]

Committed patchset #8 (id:140001)

[commit-bot: I haz the power, 2016-12-08 21:54:15]

Description was changed from

==========
Explicit WTF:: qualifier for passed, unretained, wrapUnique and makeUnique.

The functions listed in the title of the CL description exist both in
WTF:: and in base:: namespaces and differ only by the case (uppercase vs
lowercase) of the first character in their identifiers.  This will lead
to compile errors after renaming the WTF functions to follow Chromium
style (PascalCaseFunctionNames) because of |using| statements that today
enable the WTF functions to be used without namespace qualification -
such usage will be ambiguous after the rename.  Example:

    ../../third_party/WebKit/Source/platform/WaitableEvent.cpp:17:11:
    error: call to 'WrapUnique' is ambiguous
      impl_ = WrapUnique(new base::WaitableEvent(
              ^~~~~~~~~~
    ../../base/memory/ptr_util.h:17:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
    ../../third_party/WebKit/Source/wtf/PtrUtil.h:16:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
This CL
1) adds WTF:: namespace qualifier to all calls to the affected WTF
   functions
2) removes |using| statements that import the affected WTF functions
   into the global namespace

The second change means that failure to namespace-qualify a call will be
a compile error (e.g. error: use of undeclared identifier 'WrapUnique')
when the argument doesn't come from base or WTF namespace (preventing
reoccurence of the problem in these cases).  When the argument comes
from base or WTF namespace, then ADL will pick the function from the
corresponding namespace.

The Google C++ Style Guide allows using type aliases (including |using
other_namespace::Foo|), although it also says to prefer placing
nonmember functions in a namespace and to use completely global
functions rarely.  The guide also explicitly says "You may not use a
using-directive to make all names from a namespace available" - this is
not what WTF is doing here, but I guess one could argue that all the
individual |using WTF::foo| declarations taken together are not that
different from just doing |using namespace WTF|.  FWIW, I don't see
(grepping for 'using.*base') any |using| statement in a header file
under //base that would pull a name from base:: into the global
namespace (except using base::PathService which is there for legacy
reasons).  References:
- https://google.github.io/styleguide/cppguide.html#Aliases
- https://google.github.io/styleguide/cppguide.html#Namespaces
-
https://google.github.io/styleguide/cppguide.html#Nonmember,_Static_Member,_a...

This CL was generated in a fairly mechanical way:
- Run the following under third_party/WebKit/Source for (passed,
  unretained, wrapUnique):
  $ ag '\bpassed\b\(' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bpassed\b(/\1WTF::passed(/g' -i
- Run the following under third_party/WebKit/Source (for makeUnique):
  $ ag '\bmakeUnique' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bmakeUnique<\(.*\)>(/\1WTF::makeUnique<\2>(/g' -i
- Manually remove |using WTF::foo| declarations.
- Manually fixup function definitions (where no WTF:: qualifier should
  be used).
- git cl format
- Manually fix formatting inside comments.
- Do a self-review.

Affected functions:
- third_party/WebKit/Source/wtf/PtrUtil.h:
  - WTF::wrapUnique / base::WrapUnique
  - WTF::makeUnique / base::MakeUnique
- third_party/WebKit/Source/wtf/Functional.h:
  - WTF::passed / base::Passed
  - WTF::unretained / base::Unretained

Note that there are a lot more using statements under WTF that can
potentially conflict with things from other namespaces.  This CL tweaks
only names that are known to cause compile failures after the automatic
rename from blinkStyleFunctions into ChromiumStyleFunctions.  In
particular, the following things are not tweaked by this CL:
- wtf/ASCIICType.h (e.g. WTF::isASCIILower function)
- wtf/AutoReset.h (WTF::AutoReset class)
- wtf/text/Base64.h (e.g. WTF::base64Encode function)
- wtf/Time.h (e.g. WTF::TimeDelta class)

BUG=670908
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
==========

to

==========
Explicit WTF:: qualifier for passed, unretained, wrapUnique and makeUnique.

The functions listed in the title of the CL description exist both in
WTF:: and in base:: namespaces and differ only by the case (uppercase vs
lowercase) of the first character in their identifiers.  This will lead
to compile errors after renaming the WTF functions to follow Chromium
style (PascalCaseFunctionNames) because of |using| statements that today
enable the WTF functions to be used without namespace qualification -
such usage will be ambiguous after the rename.  Example:

    ../../third_party/WebKit/Source/platform/WaitableEvent.cpp:17:11:
    error: call to 'WrapUnique' is ambiguous
      impl_ = WrapUnique(new base::WaitableEvent(
              ^~~~~~~~~~
    ../../base/memory/ptr_util.h:17:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
    ../../third_party/WebKit/Source/wtf/PtrUtil.h:16:20:
    note: candidate function [with T = base::WaitableEvent]
    std::unique_ptr<T> WrapUnique(T* ptr) {
                       ^
This CL
1) adds WTF:: namespace qualifier to all calls to the affected WTF
   functions
2) removes |using| statements that import the affected WTF functions
   into the global namespace

The second change means that failure to namespace-qualify a call will be
a compile error (e.g. error: use of undeclared identifier 'WrapUnique')
when the argument doesn't come from base or WTF namespace (preventing
reoccurence of the problem in these cases).  When the argument comes
from base or WTF namespace, then ADL will pick the function from the
corresponding namespace.

The Google C++ Style Guide allows using type aliases (including |using
other_namespace::Foo|), although it also says to prefer placing
nonmember functions in a namespace and to use completely global
functions rarely.  The guide also explicitly says "You may not use a
using-directive to make all names from a namespace available" - this is
not what WTF is doing here, but I guess one could argue that all the
individual |using WTF::foo| declarations taken together are not that
different from just doing |using namespace WTF|.  FWIW, I don't see
(grepping for 'using.*base') any |using| statement in a header file
under //base that would pull a name from base:: into the global
namespace (except using base::PathService which is there for legacy
reasons).  References:
- https://google.github.io/styleguide/cppguide.html#Aliases
- https://google.github.io/styleguide/cppguide.html#Namespaces
-
https://google.github.io/styleguide/cppguide.html#Nonmember,_Static_Member,_a...

This CL was generated in a fairly mechanical way:
- Run the following under third_party/WebKit/Source for (passed,
  unretained, wrapUnique):
  $ ag '\bpassed\b\(' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bpassed\b(/\1WTF::passed(/g' -i
- Run the following under third_party/WebKit/Source (for makeUnique):
  $ ag '\bmakeUnique' -l | xargs -n 1 \
      sed -e 's/\([^:]\)\bmakeUnique<\(.*\)>(/\1WTF::makeUnique<\2>(/g' -i
- Manually remove |using WTF::foo| declarations.
- Manually fixup function definitions (where no WTF:: qualifier should
  be used).
- git cl format
- Manually fix formatting inside comments.
- Do a self-review.

Affected functions:
- third_party/WebKit/Source/wtf/PtrUtil.h:
  - WTF::wrapUnique / base::WrapUnique
  - WTF::makeUnique / base::MakeUnique
- third_party/WebKit/Source/wtf/Functional.h:
  - WTF::passed / base::Passed
  - WTF::unretained / base::Unretained

Note that there are a lot more using statements under WTF that can
potentially conflict with things from other namespaces.  This CL tweaks
only names that are known to cause compile failures after the automatic
rename from blinkStyleFunctions into ChromiumStyleFunctions.  In
particular, the following things are not tweaked by this CL:
- wtf/ASCIICType.h (e.g. WTF::isASCIILower function)
- wtf/AutoReset.h (WTF::AutoReset class)
- wtf/text/Base64.h (e.g. WTF::base64Encode function)
- wtf/Time.h (e.g. WTF::TimeDelta class)

BUG=670908
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2

Committed: https://crrev.com/9d858647530db2c22e1267e443034d23f2e602d9
Cr-Commit-Position: refs/heads/master@{#437358}
==========

[commit-bot: I haz the power, 2016-12-08 21:54:19]

Patchset 8 (id:??) landed as
https://crrev.com/9d858647530db2c22e1267e443034d23f2e602d9
Cr-Commit-Position: refs/heads/master@{#437358}