Fixing std::swap(x, x) in base.

base/pickle.cc

 // Copyright (c) 2012 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.
 
 #include "base/pickle.h"
 
 #include <stdlib.h>
 
 #include <algorithm>  // for max()
 #include <limits>
@@ skipping 289 matching lines @@
   Resize(other.header_->payload_size);
   memcpy(header_, other.header_, header_size_ + other.header_->payload_size);
 }
 
 Pickle::~Pickle() {
   if (capacity_after_header_ != kCapacityReadOnly)
     free(header_);
 }
 
 Pickle& Pickle::operator=(const Pickle& other) {
-  if (this == &other) {
-    NOTREACHED();

[dcheng, 2017/04/05 20:22:18]

The post condition for CopyAssignment in N4618 [1] is:

t is equivalent to v, the value of v is unchanged

[1] http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4618.pdf

So I think we need to keep this self-assignment check for copy assignment.

[dyaroshev, 2017/04/05 20:42:47]

This NOTREACHED mislead me - I read it as move assignment.
Can I please drop it, it's super weird?

[dcheng, 2017/04/05 20:45:49]

Dropping the NOTREACHED() seems fine, as long as keep the early return or skip
the body.

[dyaroshev, 2017/04/05 20:54:17]

Done.

-    return *this;
-  }
   if (capacity_after_header_ == kCapacityReadOnly) {
     header_ = NULL;
     capacity_after_header_ = 0;
   }
   if (header_size_ != other.header_size_) {
     free(header_);
     header_ = NULL;
     header_size_ = other.header_size_;
   }
   Resize(other.header_->payload_size);
   memcpy(header_, other.header_,

[danakj, 2017/04/05 19:17:40]

memcpy of overlapping memory is not allowed

[dyaroshev, 2017/04/05 20:42:47]

I reverted this file.

          other.header_size_ + other.header_->payload_size);
   write_offset_ = other.write_offset_;
   return *this;
 }
 
 bool Pickle::WriteString(const StringPiece& value) {
   if (!WriteInt(static_cast<int>(value.size())))
     return false;
 
   return WriteBytes(value.data(), static_cast<int>(value.size()));
@@ skipping 138 matching lines @@
 
 inline void Pickle::WriteBytesCommon(const void* data, size_t length) {
   DCHECK_NE(kCapacityReadOnly, capacity_after_header_)
       << "oops: pickle is readonly";
   MSAN_CHECK_MEM_IS_INITIALIZED(data, length);
   void* write = ClaimUninitializedBytesInternal(length);
   memcpy(write, data, length);
 }
 
 }  // namespace base