Fix the blimp settings crash.

blimp/client/core/context/blimp_client_context_impl.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 "blimp/client/core/context/blimp_client_context_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 129 matching lines @@
                             base::Unretained(net_components_.get())));
 
   UMA_HISTOGRAM_BOOLEAN("Blimp.Supported", true);
 }
 
 BlimpClientContextImpl::~BlimpClientContextImpl() {
   io_thread_task_runner_->DeleteSoon(FROM_HERE, net_components_.release());
   connection_status_.RemoveObserver(this);
 }
 
 void BlimpClientContextImpl::SetDelegate(BlimpClientContextDelegate* delegate) {

[Khushal, 2016/11/03 00:13:35]

This is being called with a null delegate from its dtor. See
https://cs.chromium.org/chromium/src/chrome/browser/android/blimp/chrome_blim...

So what you want to is:
DCHECK(!delegate_ || !delegate), basically one of them should be null. Then,

if (delegate_) {
  assignment_fetcher_ = nullptr;
}
delegate_ = delegate;
if (delegate_) {
  assignment_fetcher_ = // Create the fetcher.
}

[nyquist, 2016/11/03 00:21:40]

This makes sense to me.

[xingliu, 2016/11/03 00:33:31]

Sorry I didn't notice in dtor it sets to nullptr.
But assignment_fetcher_can probably out live the delegate? 

[Khushal, 2016/11/03 00:50:48]

I just looked at that class, and yes, it does look like the fetcher doesn't have
anything to do with the delegate. But in that case, I'm super confused why we
have a delegate callback for creating the IdentitySource. Why don't we pass it
in the context's ctor, like the other things tied to the Profile when creating
it.
For instance, the PrefService is passed at that time here:
https://cs.chromium.org/chromium/src/chrome/browser/android/blimp/blimp_clien...

So why not create the IdentityProvider there as well,
base::WrapUnique<IdentityProvider>(new ProfileIdentityProvider(
      SigninManagerFactory::GetForProfile(profile_),
      ProfileOAuth2TokenServiceFactory::GetForProfile(profile_),
      base::Closure()))
You can get profile the same way, Profile::FromBrowserContext(context).

Am I missing something here?

[xingliu, 2016/11/03 01:45:37]

Yeah, that's probably the right way to do that :)

   delegate_ = delegate;
+
+  // |assignment_fetcher_| needs services from BlimpClientContextDelegate, so
+  // it can't be created in the constructor.
+  DCHECK(delegate_);
+  assignment_fetcher_ = base::MakeUnique<AssignmentFetcher>(
+      io_thread_task_runner_, file_thread_task_runner_,
+      delegate_->CreateIdentityProvider(), GetAssignerURL(),
+      base::Bind(&BlimpClientContextImpl::OnAssignmentReceived,
+                 weak_factory_.GetWeakPtr()),
+      base::Bind(&BlimpClientContextDelegate::OnAuthenticationError,
+                 base::Unretained(delegate_)));
 }
 
 std::unique_ptr<BlimpContents> BlimpClientContextImpl::CreateBlimpContents(
     gfx::NativeWindow window) {
   std::unique_ptr<BlimpContents> blimp_contents =
       blimp_contents_manager_->CreateBlimpContents(window);
   if (blimp_contents)
     delegate_->AttachBlimpContentsHelpers(blimp_contents.get());
   return blimp_contents;
 }
 
 void BlimpClientContextImpl::Connect() {
-  if (!assignment_fetcher_) {
-    assignment_fetcher_ = base::MakeUnique<AssignmentFetcher>(
-        io_thread_task_runner_, file_thread_task_runner_,
-        delegate_->CreateIdentityProvider(), GetAssignerURL(),
-        base::Bind(&BlimpClientContextImpl::OnAssignmentReceived,
-                   weak_factory_.GetWeakPtr()),
-        base::Bind(&BlimpClientContextDelegate::OnAuthenticationError,
-                   base::Unretained(delegate_)));
-  }
+  DCHECK(assignment_fetcher_);
   assignment_fetcher_->Fetch();
 }
 
 void BlimpClientContextImpl::ConnectWithAssignment(
     const Assignment& assignment) {
   io_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ClientNetworkComponents::ConnectWithAssignment,
                  base::Unretained(net_components_.get()), assignment));
 }
 
 std::unordered_map<std::string, std::string>
 BlimpClientContextImpl::CreateFeedbackData() {
   return CreateBlimpFeedbackData(blimp_contents_manager_.get());
 }
 
 IdentitySource* BlimpClientContextImpl::GetIdentitySource() {
+  DCHECK(assignment_fetcher_);
   return assignment_fetcher_->GetIdentitySource();
 }
 
 ConnectionStatus* BlimpClientContextImpl::GetConnectionStatus() {
   return &connection_status_;
 }
 
 GURL BlimpClientContextImpl::GetAssignerURL() {
   return GURL(kDefaultAssignerUrl);
 }
@@ skipping 69 matching lines @@
     if (result >= 0) {
       delegate_->OnEngineDisconnected(result);
     } else {
       delegate_->OnNetworkDisconnected(result);
     }
   }
 }
 
 }  // namespace client
 }  // namespace blimp