[Remoting Android] Refactor ClientTelemetryLogger

remoting/base/telemetry_log_writer.cc

 // Copyright 2016 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 "remoting/base/telemetry_log_writer.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
 #include "net/http/http_status_code.h"
 
 namespace remoting {
 
 const int kMaxSendAttempts = 5;
 
 TelemetryLogWriter::TelemetryLogWriter(
     const std::string& telemetry_base_url,
     std::unique_ptr<UrlRequestFactory> request_factory)
     : telemetry_base_url_(telemetry_base_url),
-      request_factory_(std::move(request_factory)) {}
+      request_factory_(std::move(request_factory)),
+      weak_factory_(this) {
+  weak_ptr_ = weak_factory_.GetWeakPtr();

[Sergey Ulanov, 2017/01/19 00:50:38]

this can be initialized in the initializer list above (if you move weak_ptr_
after weak_factory_), but weak_ptr can be removed completely if GetWeakPtr()
doesn't need to be thread-safe.

[Yuwei, 2017/01/19 23:00:00]

Obsolete.

BTW I don't think you can move weak_ptr_ after weak_factory_ since weak_factory_
is supposed to be the last member to initialize so that it can get destroyed
first.

[Sergey Ulanov, 2017/01/23 00:36:49]

Yes, it's better to keep WeakFactory last, but in practice it makes any
difference very rarely. In this case it certainly doesn't matter - it's safe to
destroy weak_ptr_ before WeakFactory.

[Yuwei, 2017/01/23 02:19:47]

Acknowledged.

+}
 TelemetryLogWriter::~TelemetryLogWriter() {}
 
 void TelemetryLogWriter::SetAuthToken(const std::string& auth_token) {
   DCHECK(thread_checker_.CalledOnValidThread());
   auth_token_ = auth_token;
   SendPendingEntries();
 }
 
 void TelemetryLogWriter::SetAuthClosure(const base::Closure& closure) {
   DCHECK(thread_checker_.CalledOnValidThread());
   auth_closure_ = closure;
 }
 
 void TelemetryLogWriter::Log(const ChromotingEvent& entry) {
   DCHECK(thread_checker_.CalledOnValidThread());
   pending_entries_.push_back(entry);
   SendPendingEntries();
 }
 
+base::WeakPtr<TelemetryLogWriter> TelemetryLogWriter::GetWeakPtr() {
+  return weak_ptr_;
+}
+
 void TelemetryLogWriter::SendPendingEntries() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (request_ || pending_entries_.empty()) {
     return;
   }
 
   std::unique_ptr<base::ListValue> events(new base::ListValue());
   while (!pending_entries_.empty()) {
     ChromotingEvent& entry = pending_entries_.front();
     events->Append(entry.CopyDictionaryValue());
@@ skipping 56 matching lines @@
   request_.reset();  // This may also destroy the result.
   if (should_call_auth_closure) {
     VLOG(1) << "Request is unauthorized. Trying to call the auth closure...";
     auth_closure_.Run();
   } else {
     SendPendingEntries();
   }
 }
 
 }  // namespace remoting